| 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 // 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 attributes = element->getAttributes();
57 XMLSize_t attributeCount = attributes->getLength();
58
59 for(XMLSize_t attribute_index = 0; attribute_index < attributeCount;
60 ++attribute_index)
61 {
62 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
63
64 if(attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
65 {
66 continue;
67 }
68
69 const xercesc::DOMAttr* const attribute =
70 dynamic_cast<xercesc::DOMAttr*>(attribute_node);
71 if(attribute == nullptr)
72 {
73 G4Exception("G4GDMLReadParamvol::Box_dimensionsRead()", "InvalidRead",
74 FatalException, "No attribute found!");
75 return;
76 }
77 const G4String attName = Transcode(attribute->getName());
78 const G4String attValue = Transcode(attribute->getValue());
79
80 if(attName == "lunit")
81 {
82 lunit = G4UnitDefinition::GetValueOf(attValue);
83 if(G4UnitDefinition::GetCategory(attValue) != "Length")
84 {
85 G4Exception("G4GDMLReadParamvol::Box_dimensionsRead()", "InvalidRead",
86 FatalException, "Invalid unit for length!");
87 }
88 }
89 else if(attName == "x")
90 {
91 parameter.dimension[0] = eval.Evaluate(attValue);
92 }
93 else if(attName == "y")
94 {
95 parameter.dimension[1] = eval.Evaluate(attValue);
96 }
97 else if(attName == "z")
98 {
99 parameter.dimension[2] = eval.Evaluate(attValue);
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 attributes = element->getAttributes();
116 XMLSize_t attributeCount = attributes->getLength();
117
118 for(XMLSize_t attribute_index = 0; attribute_index < attributeCount;
119 ++attribute_index)
120 {
121 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
122
123 if(attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
124 {
125 continue;
126 }
127
128 const xercesc::DOMAttr* const attribute =
129 dynamic_cast<xercesc::DOMAttr*>(attribute_node);
130 if(attribute == nullptr)
131 {
132 G4Exception("G4GDMLReadParamvol::Trd_dimensionsRead()", "InvalidRead",
133 FatalException, "No attribute found!");
134 return;
135 }
136 const G4String attName = Transcode(attribute->getName());
137 const G4String attValue = Transcode(attribute->getValue());
138
139 if(attName == "lunit")
140 {
141 lunit = G4UnitDefinition::GetValueOf(attValue);
142 if(G4UnitDefinition::GetCategory(attValue) != "Length")
143 {
144 G4Exception("G4GDMLReadParamvol::Trd_dimensionsRead()", "InvalidRead",
145 FatalException, "Invalid unit for length!");
146 }
147 }
148 else if(attName == "x1")
149 {
150 parameter.dimension[0] = eval.Evaluate(attValue);
151 }
152 else if(attName == "x2")
153 {
154 parameter.dimension[1] = eval.Evaluate(attValue);
155 }
156 else if(attName == "y1")
157 {
158 parameter.dimension[2] = eval.Evaluate(attValue);
159 }
160 else if(attName == "y2")
161 {
162 parameter.dimension[3] = eval.Evaluate(attValue);
163 }
164 else if(attName == "z")
165 {
166 parameter.dimension[4] = eval.Evaluate(attValue);
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 attributes = element->getAttributes();
186 XMLSize_t attributeCount = attributes->getLength();
187
188 for(XMLSize_t attribute_index = 0; attribute_index < attributeCount;
189 ++attribute_index)
190 {
191 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
192
193 if(attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
194 {
195 continue;
196 }
197
198 const xercesc::DOMAttr* const attribute =
199 dynamic_cast<xercesc::DOMAttr*>(attribute_node);
200 if(attribute == nullptr)
201 {
202 G4Exception("G4GDMLReadParamvol::Trap_dimensionsRead()", "InvalidRead",
203 FatalException, "No attribute found!");
204 return;
205 }
206 const G4String attName = Transcode(attribute->getName());
207 const G4String attValue = Transcode(attribute->getValue());
208
209 if(attName == "lunit")
210 {
211 lunit = G4UnitDefinition::GetValueOf(attValue);
212 if(G4UnitDefinition::GetCategory(attValue) != "Length")
213 {
214 G4Exception("G4GDMLReadParamvol::Trap_dimensionsRead()", "InvalidRead",
215 FatalException, "Invalid unit for length!");
216 }
217 }
218 else if(attName == "aunit")
219 {
220 aunit = G4UnitDefinition::GetValueOf(attValue);
221 if(G4UnitDefinition::GetCategory(attValue) != "Angle")
222 {
223 G4Exception("G4GDMLReadParamvol::Trap_dimensionsRead()", "InvalidRead",
224 FatalException, "Invalid unit for angle!");
225 }
226 }
227 else if(attName == "z")
228 {
229 parameter.dimension[0] = eval.Evaluate(attValue);
230 }
231 else if(attName == "theta")
232 {
233 parameter.dimension[1] = eval.Evaluate(attValue);
234 }
235 else if(attName == "phi")
236 {
237 parameter.dimension[2] = eval.Evaluate(attValue);
238 }
239 else if(attName == "y1")
240 {
241 parameter.dimension[3] = eval.Evaluate(attValue);
242 }
243 else if(attName == "x1")
244 {
245 parameter.dimension[4] = eval.Evaluate(attValue);
246 }
247 else if(attName == "x2")
248 {
249 parameter.dimension[5] = eval.Evaluate(attValue);
250 }
251 else if(attName == "alpha1")
252 {
253 parameter.dimension[6] = eval.Evaluate(attValue);
254 }
255 else if(attName == "y2")
256 {
257 parameter.dimension[7] = eval.Evaluate(attValue);
258 }
259 else if(attName == "x3")
260 {
261 parameter.dimension[8] = eval.Evaluate(attValue);
262 }
263 else if(attName == "x4")
264 {
265 parameter.dimension[9] = eval.Evaluate(attValue);
266 }
267 else if(attName == "alpha2")
268 {
269 parameter.dimension[10] = eval.Evaluate(attValue);
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 attributes = element->getAttributes();
295 XMLSize_t attributeCount = attributes->getLength();
296
297 for(XMLSize_t attribute_index = 0; attribute_index < attributeCount;
298 ++attribute_index)
299 {
300 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
301
302 if(attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
303 {
304 continue;
305 }
306
307 const xercesc::DOMAttr* const attribute =
308 dynamic_cast<xercesc::DOMAttr*>(attribute_node);
309 if(attribute == nullptr)
310 {
311 G4Exception("G4GDMLReadParamvol::Tube_dimensionsRead()", "InvalidRead",
312 FatalException, "No attribute found!");
313 return;
314 }
315 const G4String attName = Transcode(attribute->getName());
316 const G4String attValue = Transcode(attribute->getValue());
317
318 if(attName == "lunit")
319 {
320 lunit = G4UnitDefinition::GetValueOf(attValue);
321 if(G4UnitDefinition::GetCategory(attValue) != "Length")
322 {
323 G4Exception("G4GDMLReadParamvol::Tube_dimensionsRead()", "InvalidRead",
324 FatalException, "Invalid unit for length!");
325 }
326 }
327 else if(attName == "aunit")
328 {
329 aunit = G4UnitDefinition::GetValueOf(attValue);
330 if(G4UnitDefinition::GetCategory(attValue) != "Angle")
331 {
332 G4Exception("G4GDMLReadParamvol::Tube_dimensionsRead()", "InvalidRead",
333 FatalException, "Invalid unit for angle!");
334 }
335 }
336 else if(attName == "InR")
337 {
338 parameter.dimension[0] = eval.Evaluate(attValue);
339 }
340 else if(attName == "OutR")
341 {
342 parameter.dimension[1] = eval.Evaluate(attValue);
343 }
344 else if(attName == "hz")
345 {
346 parameter.dimension[2] = eval.Evaluate(attValue);
347 }
348 else if(attName == "StartPhi")
349 {
350 parameter.dimension[3] = eval.Evaluate(attValue);
351 }
352 else if(attName == "DeltaPhi")
353 {
354 parameter.dimension[4] = eval.Evaluate(attValue);
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 attributes = element->getAttributes();
374 XMLSize_t attributeCount = attributes->getLength();
375
376 for(XMLSize_t attribute_index = 0; attribute_index < attributeCount;
377 ++attribute_index)
378 {
379 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
380
381 if(attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
382 {
383 continue;
384 }
385
386 const xercesc::DOMAttr* const attribute =
387 dynamic_cast<xercesc::DOMAttr*>(attribute_node);
388 if(attribute == nullptr)
389 {
390 G4Exception("G4GDMLReadParamvol::Cone_dimensionsRead()", "InvalidRead",
391 FatalException, "No attribute found!");
392 return;
393 }
394 const G4String attName = Transcode(attribute->getName());
395 const G4String attValue = Transcode(attribute->getValue());
396
397 if(attName == "lunit")
398 {
399 lunit = G4UnitDefinition::GetValueOf(attValue);
400 if(G4UnitDefinition::GetCategory(attValue) != "Length")
401 {
402 G4Exception("G4GDMLReadParamvol::Cone_dimensionsRead()", "InvalidRead",
403 FatalException, "Invalid unit for length!");
404 }
405 }
406 else if(attName == "aunit")
407 {
408 aunit = G4UnitDefinition::GetValueOf(attValue);
409 if(G4UnitDefinition::GetCategory(attValue) != "Angle")
410 {
411 G4Exception("G4GDMLReadParamvol::Cone_dimensions()", "InvalidRead",
412 FatalException, "Invalid unit for angle!");
413 }
414 }
415 else if(attName == "rmin1")
416 {
417 parameter.dimension[0] = eval.Evaluate(attValue);
418 }
419 else if(attName == "rmax1")
420 {
421 parameter.dimension[1] = eval.Evaluate(attValue);
422 }
423 else if(attName == "rmin2")
424 {
425 parameter.dimension[2] = eval.Evaluate(attValue);
426 }
427 else if(attName == "rmax2")
428 {
429 parameter.dimension[3] = eval.Evaluate(attValue);
430 }
431 else if(attName == "z")
432 {
433 parameter.dimension[4] = eval.Evaluate(attValue);
434 }
435 else if(attName == "startphi")
436 {
437 parameter.dimension[5] = eval.Evaluate(attValue);
438 }
439 else if(attName == "deltaphi")
440 {
441 parameter.dimension[6] = eval.Evaluate(attValue);
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 attributes = element->getAttributes();
463 XMLSize_t attributeCount = attributes->getLength();
464
465 for(XMLSize_t attribute_index = 0; attribute_index < attributeCount;
466 ++attribute_index)
467 {
468 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
469
470 if(attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
471 {
472 continue;
473 }
474
475 const xercesc::DOMAttr* const attribute =
476 dynamic_cast<xercesc::DOMAttr*>(attribute_node);
477 if(attribute == nullptr)
478 {
479 G4Exception("G4GDMLReadParamvol::Sphere_dimensionsRead()", "InvalidRead",
480 FatalException, "No attribute found!");
481 return;
482 }
483 const G4String attName = Transcode(attribute->getName());
484 const G4String attValue = Transcode(attribute->getValue());
485
486 if(attName == "lunit")
487 {
488 lunit = G4UnitDefinition::GetValueOf(attValue);
489 if(G4UnitDefinition::GetCategory(attValue) != "Length")
490 {
491 G4Exception("G4GDMLReadParamvol::Sphere_dimensionsRead()",
492 "InvalidRead", FatalException, "Invalid unit for length!");
493 }
494 }
495 else if(attName == "aunit")
496 {
497 aunit = G4UnitDefinition::GetValueOf(attValue);
498 if(G4UnitDefinition::GetCategory(attValue) != "Angle")
499 {
500 G4Exception("G4GDMLReadParamvol::Sphere_dimensionsRead()",
501 "InvalidRead", FatalException, "Invalid unit for angle!");
502 }
503 }
504 else if(attName == "rmin")
505 {
506 parameter.dimension[0] = eval.Evaluate(attValue);
507 }
508 else if(attName == "rmax")
509 {
510 parameter.dimension[1] = eval.Evaluate(attValue);
511 }
512 else if(attName == "startphi")
513 {
514 parameter.dimension[2] = eval.Evaluate(attValue);
515 }
516 else if(attName == "deltaphi")
517 {
518 parameter.dimension[3] = eval.Evaluate(attValue);
519 }
520 else if(attName == "starttheta")
521 {
522 parameter.dimension[4] = eval.Evaluate(attValue);
523 }
524 else if(attName == "deltatheta")
525 {
526 parameter.dimension[5] = eval.Evaluate(attValue);
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 attributes = element->getAttributes();
546 XMLSize_t attributeCount = attributes->getLength();
547
548 for(XMLSize_t attribute_index = 0; attribute_index < attributeCount;
549 ++attribute_index)
550 {
551 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
552
553 if(attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
554 {
555 continue;
556 }
557
558 const xercesc::DOMAttr* const attribute =
559 dynamic_cast<xercesc::DOMAttr*>(attribute_node);
560 if(attribute == nullptr)
561 {
562 G4Exception("G4GDMLReadParamvol::Orb_dimensionsRead()", "InvalidRead",
563 FatalException, "No attribute found!");
564 return;
565 }
566 const G4String attName = Transcode(attribute->getName());
567 const G4String attValue = Transcode(attribute->getValue());
568
569 if(attName == "lunit")
570 {
571 lunit = G4UnitDefinition::GetValueOf(attValue);
572 }
573 if(G4UnitDefinition::GetCategory(attValue) != "Length")
574 {
575 G4Exception("G4GDMLReadParamvol::Orb_dimensionsRead()", "InvalidRead",
576 FatalException, "Invalid unit for length!");
577 }
578 else if(attName == "r")
579 {
580 parameter.dimension[0] = eval.Evaluate(attValue);
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 attributes = element->getAttributes();
596 XMLSize_t attributeCount = attributes->getLength();
597
598 for(XMLSize_t attribute_index = 0; attribute_index < attributeCount;
599 ++attribute_index)
600 {
601 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
602
603 if(attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
604 {
605 continue;
606 }
607
608 const xercesc::DOMAttr* const attribute =
609 dynamic_cast<xercesc::DOMAttr*>(attribute_node);
610 if(attribute == nullptr)
611 {
612 G4Exception("G4GDMLReadParamvol::Torus_dimensionsRead()", "InvalidRead",
613 FatalException, "No attribute found!");
614 return;
615 }
616 const G4String attName = Transcode(attribute->getName());
617 const G4String attValue = Transcode(attribute->getValue());
618
619 if(attName == "lunit")
620 {
621 lunit = G4UnitDefinition::GetValueOf(attValue);
622 if(G4UnitDefinition::GetCategory(attValue) != "Length")
623 {
624 G4Exception("G4GDMLReadParamvol::Torus_dimensionsRead()", "InvalidRead",
625 FatalException, "Invalid unit for length!");
626 }
627 }
628 else if(attName == "aunit")
629 {
630 aunit = G4UnitDefinition::GetValueOf(attValue);
631 if(G4UnitDefinition::GetCategory(attValue) != "Angle")
632 {
633 G4Exception("G4GDMLReadParamvol::Torus_dimensionsRead()", "InvalidRead",
634 FatalException, "Invalid unit for angle!");
635 }
636 }
637 else if(attName == "rmin")
638 {
639 parameter.dimension[0] = eval.Evaluate(attValue);
640 }
641 else if(attName == "rmax")
642 {
643 parameter.dimension[1] = eval.Evaluate(attValue);
644 }
645 else if(attName == "rtor")
646 {
647 parameter.dimension[2] = eval.Evaluate(attValue);
648 }
649 else if(attName == "startphi")
650 {
651 parameter.dimension[3] = eval.Evaluate(attValue);
652 }
653 else if(attName == "deltaphi")
654 {
655 parameter.dimension[4] = eval.Evaluate(attValue);
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_dimensionsRead(
668 const xercesc::DOMElement* const element,
669 G4GDMLParameterisation::PARAMETER& parameter)
670 {
671 G4double lunit = 1.0;
672 const xercesc::DOMNamedNodeMap* const attributes = element->getAttributes();
673 XMLSize_t attributeCount = attributes->getLength();
674
675 for(XMLSize_t attribute_index = 0; attribute_index < attributeCount;
676 ++attribute_index)
677 {
678 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
679
680 if(attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
681 {
682 continue;
683 }
684
685 const xercesc::DOMAttr* const attribute =
686 dynamic_cast<xercesc::DOMAttr*>(attribute_node);
687 if(attribute == nullptr)
688 {
689 G4Exception("G4GDMLReadParamvol::Ellipsoid_dimensionsRead()",
690 "InvalidRead", FatalException, "No attribute found!");
691 return;
692 }
693 const G4String attName = Transcode(attribute->getName());
694 const G4String attValue = Transcode(attribute->getValue());
695
696 if(attName == "lunit")
697 {
698 lunit = G4UnitDefinition::GetValueOf(attValue);
699 if(G4UnitDefinition::GetCategory(attValue) != "Length")
700 {
701 G4Exception("G4GDMLReadParamvol::Ellipsoid_dimensionsRead()",
702 "InvalidRead", FatalException, "Invalid unit for length!");
703 }
704 }
705 else if(attName == "ax")
706 {
707 parameter.dimension[0] = eval.Evaluate(attValue);
708 }
709 else if(attName == "by")
710 {
711 parameter.dimension[1] = eval.Evaluate(attValue);
712 }
713 else if(attName == "cz")
714 {
715 parameter.dimension[2] = eval.Evaluate(attValue);
716 }
717 else if(attName == "zcut1")
718 {
719 parameter.dimension[3] = eval.Evaluate(attValue);
720 }
721 else if(attName == "zcut2")
722 {
723 parameter.dimension[4] = eval.Evaluate(attValue);
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 attributes = element->getAttributes();
743 XMLSize_t attributeCount = attributes->getLength();
744
745 for(XMLSize_t attribute_index = 0; attribute_index < attributeCount;
746 ++attribute_index)
747 {
748 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
749
750 if(attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
751 {
752 continue;
753 }
754
755 const xercesc::DOMAttr* const attribute =
756 dynamic_cast<xercesc::DOMAttr*>(attribute_node);
757 if(attribute == nullptr)
758 {
759 G4Exception("G4GDMLReadParamvol::Para_dimensionsRead()", "InvalidRead",
760 FatalException, "No attribute found!");
761 return;
762 }
763 const G4String attName = Transcode(attribute->getName());
764 const G4String attValue = Transcode(attribute->getValue());
765
766 if(attName == "lunit")
767 {
768 lunit = G4UnitDefinition::GetValueOf(attValue);
769 if(G4UnitDefinition::GetCategory(attValue) != "Length")
770 {
771 G4Exception("G4GDMLReadParamvol::Para_dimensionsRead()", "InvalidRead",
772 FatalException, "Invalid unit for length!");
773 }
774 }
775 else if(attName == "aunit")
776 {
777 aunit = G4UnitDefinition::GetValueOf(attValue);
778 if(G4UnitDefinition::GetCategory(attValue) != "Angle")
779 {
780 G4Exception("G4GDMLReadParamvol::Para_dimensionsRead()", "InvalidRead",
781 FatalException, "Invalid unit for angle!");
782 }
783 }
784 else if(attName == "x")
785 {
786 parameter.dimension[0] = eval.Evaluate(attValue);
787 }
788 else if(attName == "y")
789 {
790 parameter.dimension[1] = eval.Evaluate(attValue);
791 }
792 else if(attName == "z")
793 {
794 parameter.dimension[2] = eval.Evaluate(attValue);
795 }
796 else if(attName == "alpha")
797 {
798 parameter.dimension[3] = eval.Evaluate(attValue);
799 }
800 else if(attName == "theta")
801 {
802 parameter.dimension[4] = eval.Evaluate(attValue);
803 }
804 else if(attName == "phi")
805 {
806 parameter.dimension[5] = eval.Evaluate(attValue);
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 attributes = element->getAttributes();
827 XMLSize_t attributeCount = attributes->getLength();
828
829 for(XMLSize_t attribute_index = 0; attribute_index < attributeCount;
830 ++attribute_index)
831 {
832 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
833
834 if(attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
835 {
836 continue;
837 }
838
839 const xercesc::DOMAttr* const attribute =
840 dynamic_cast<xercesc::DOMAttr*>(attribute_node);
841 if(attribute == nullptr)
842 {
843 G4Exception("G4GDMLReadParamvol::Hype_dimensionsRead()", "InvalidRead",
844 FatalException, "No attribute found!");
845 return;
846 }
847 const G4String attName = Transcode(attribute->getName());
848 const G4String attValue = Transcode(attribute->getValue());
849
850 if(attName == "lunit")
851 {
852 lunit = G4UnitDefinition::GetValueOf(attValue);
853 if(G4UnitDefinition::GetCategory(attValue) != "Length")
854 {
855 G4Exception("G4GDMLReadParamvol::Hype_dimensionsRead()", "InvalidRead",
856 FatalException, "Invalid unit for length!");
857 }
858 }
859 else if(attName == "aunit")
860 {
861 aunit = G4UnitDefinition::GetValueOf(attValue);
862 if(G4UnitDefinition::GetCategory(attValue) != "Angle")
863 {
864 G4Exception("G4GDMLReadParamvol::Hype_dimensionsRead()", "InvalidRead",
865 FatalException, "Invalid unit for angle!");
866 }
867 }
868 else if(attName == "rmin")
869 {
870 parameter.dimension[0] = eval.Evaluate(attValue);
871 }
872 else if(attName == "rmax")
873 {
874 parameter.dimension[1] = eval.Evaluate(attValue);
875 }
876 else if(attName == "inst")
877 {
878 parameter.dimension[2] = eval.Evaluate(attValue);
879 }
880 else if(attName == "outst")
881 {
882 parameter.dimension[3] = eval.Evaluate(attValue);
883 }
884 else if(attName == "z")
885 {
886 parameter.dimension[4] = eval.Evaluate(attValue);
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_dimensionsRead(
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 attributes = element->getAttributes();
908 XMLSize_t attributeCount = attributes->getLength();
909
910 for(XMLSize_t attribute_index = 0; attribute_index < attributeCount;
911 ++attribute_index)
912 {
913 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
914
915 if(attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
916 {
917 continue;
918 }
919
920 const xercesc::DOMAttr* const attribute =
921 dynamic_cast<xercesc::DOMAttr*>(attribute_node);
922 if(attribute == nullptr)
923 {
924 G4Exception("G4GDMLReadParamvol::Polycone_dimensionsRead()",
925 "InvalidRead", FatalException, "No attribute found!");
926 return;
927 }
928 const G4String attName = Transcode(attribute->getName());
929 const G4String attValue = Transcode(attribute->getValue());
930
931 if(attName == "lunit")
932 {
933 lunit = G4UnitDefinition::GetValueOf(attValue);
934 if(G4UnitDefinition::GetCategory(attValue) != "Length")
935 {
936 G4Exception("G4GDMLReadParamvol::Polycone_dimensionsRead()",
937 "InvalidRead", FatalException, "Invalid unit for length!");
938 }
939 }
940 else if(attName == "aunit")
941 {
942 aunit = G4UnitDefinition::GetValueOf(attValue);
943 if(G4UnitDefinition::GetCategory(attValue) != "Angle")
944 {
945 G4Exception("G4GDMLReadParamvol::Polycone_dimensionsRead()",
946 "InvalidRead", FatalException, "Invalid unit for angle!");
947 }
948 }
949 else if(attName == "startPhi")
950 {
951 parameter.dimension[0] = eval.Evaluate(attValue);
952 }
953 else if(attName == "openPhi")
954 {
955 parameter.dimension[1] = eval.Evaluate(attValue);
956 }
957 else if(attName == "numRZ")
958 {
959 parameter.dimension[2] = eval.Evaluate(attValue);
960 }
961 }
962
963 parameter.dimension[0] *= aunit;
964 parameter.dimension[1] *= aunit;
965
966 for(xercesc::DOMNode* iter = element->getFirstChild(); iter != nullptr;
967 iter = iter->getNextSibling())
968 {
969 if(iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE)
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::Polycone_dimensionsRead()",
979 "InvalidRead", FatalException, "No child found!");
980 return;
981 }
982 const G4String tag = Transcode(child->getTagName());
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] = zplaneList[i].rmin * lunit;
994 parameter.dimension[4 + i * 3] = zplaneList[i].rmax * lunit;
995 parameter.dimension[5 + i * 3] = zplaneList[i].z * lunit;
996 }
997 }
998
999 // --------------------------------------------------------------------
1000 void G4GDMLReadParamvol::Polyhedra_dimensionsRead(
1001 const xercesc::DOMElement* const element,
1002 G4GDMLParameterisation::PARAMETER& parameter)
1003 {
1004 G4double lunit = 1.0;
1005 G4double aunit = 1.0;
1006
1007 std::vector<zplaneType> zplaneList;
1008
1009 const xercesc::DOMNamedNodeMap* const attributes = element->getAttributes();
1010 XMLSize_t attributeCount = attributes->getLength();
1011
1012 for(XMLSize_t attribute_index = 0; attribute_index < attributeCount;
1013 ++attribute_index)
1014 {
1015 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
1016
1017 if(attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
1018 {
1019 continue;
1020 }
1021
1022 const xercesc::DOMAttr* const attribute =
1023 dynamic_cast<xercesc::DOMAttr*>(attribute_node);
1024 if(attribute == nullptr)
1025 {
1026 G4Exception("G4GDMLReadParamvol::Polycone_dimensionsRead()",
1027 "InvalidRead", FatalException, "No attribute found!");
1028 return;
1029 }
1030 const G4String attName = Transcode(attribute->getName());
1031 const G4String attValue = Transcode(attribute->getValue());
1032
1033 if(attName == "lunit")
1034 {
1035 lunit = G4UnitDefinition::GetValueOf(attValue);
1036 if(G4UnitDefinition::GetCategory(attValue) != "Length")
1037 {
1038 G4Exception("G4GDMLReadParamvol::Polyhedra_dimensionsRead()",
1039 "InvalidRead", FatalException, "Invalid unit for length!");
1040 }
1041 }
1042 else if(attName == "aunit")
1043 {
1044 aunit = G4UnitDefinition::GetValueOf(attValue);
1045 if(G4UnitDefinition::GetCategory(attValue) != "Angle")
1046 {
1047 G4Exception("G4GDMLReadParamvol::Polyhedra_dimensionsRead()",
1048 "InvalidRead", FatalException, "Invalid unit for angle!");
1049 }
1050 }
1051 else if(attName == "startPhi")
1052 {
1053 parameter.dimension[0] = eval.Evaluate(attValue);
1054 }
1055 else if(attName == "openPhi")
1056 {
1057 parameter.dimension[1] = eval.Evaluate(attValue);
1058 }
1059 else if(attName == "numRZ")
1060 {
1061 parameter.dimension[2] = eval.Evaluate(attValue);
1062 }
1063 else if(attName == "numSide")
1064 {
1065 parameter.dimension[3] = eval.Evaluate(attValue);
1066 }
1067 }
1068
1069 parameter.dimension[0] *= aunit;
1070 parameter.dimension[1] *= aunit;
1071
1072 for(auto iter = element->getFirstChild(); iter != nullptr;
1073 iter = iter->getNextSibling())
1074 {
1075 if(iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE)
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::PolyhedraRead()", "InvalidRead",
1085 FatalException, "No child found!");
1086 return;
1087 }
1088 const G4String tag = Transcode(child->getTagName());
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] = zplaneList[i].rmin * lunit;
1100 parameter.dimension[5 + i * 3] = zplaneList[i].rmax * lunit;
1101 parameter.dimension[6 + i * 3] = zplaneList[i].z * lunit;
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->getFirstChild(); iter != nullptr;
1115 iter = iter->getNextSibling())
1116 {
1117 if(iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE)
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::ParametersRead()", "InvalidRead",
1127 FatalException, "No child found!");
1128 return;
1129 }
1130 const G4String tag = Transcode(child->getTagName());
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(RefRead(child)));
1142 }
1143 else if(tag == "rotationref")
1144 {
1145 rotation = GetRotation(GenerateName(RefRead(child)));
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, parameter);
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, parameter);
1190 }
1191 else if(tag == "polyhedra_dimensions")
1192 {
1193 Polyhedra_dimensionsRead(child, parameter);
1194 }
1195 else if(tag == "hype_dimensions")
1196 {
1197 Hype_dimensionsRead(child, parameter);
1198 }
1199 else
1200 {
1201 G4String error_msg = "Unknown tag in parameters: " + tag;
1202 G4Exception("G4GDMLReadParamvol::ParametersRead()", "ReadError",
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->getFirstChild(); iter != nullptr;
1223 iter = iter->getNextSibling())
1224 {
1225 if(iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE)
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::ParameterisedRead()", "InvalidRead",
1235 FatalException, "No child found!");
1236 return;
1237 }
1238 const G4String tag = Transcode(child->getTagName());
1239
1240 if(tag == "parameters")
1241 {
1242 const xercesc::DOMNamedNodeMap* const attributes =
1243 element->getAttributes();
1244 XMLSize_t attributeCount = attributes->getLength();
1245 for(XMLSize_t attribute_index = 0; attribute_index < attributeCount;
1246 ++attribute_index)
1247 {
1248 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
1249
1250 if(attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
1251 {
1252 continue;
1253 }
1254
1255 const xercesc::DOMAttr* const attribute =
1256 dynamic_cast<xercesc::DOMAttr*>(attribute_node);
1257 if(attribute == nullptr)
1258 {
1259 G4Exception("G4GDMLReadParamvol::ParameterisedRead()", "InvalidRead",
1260 FatalException, "No attribute found!");
1261 return;
1262 }
1263 const G4String attName = Transcode(attribute->getName());
1264 const G4String attValue = Transcode(attribute->getValue());
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_contentRead);
1278 }
1279 }
1280 }
1281 }
1282
1283 // --------------------------------------------------------------------
1284 void G4GDMLReadParamvol::Paramvol_contentRead(
1285 const xercesc::DOMElement* const element)
1286 {
1287 for(xercesc::DOMNode* iter = element->getFirstChild(); iter != nullptr;
1288 iter = iter->getNextSibling())
1289 {
1290 if(iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE)
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::Paramvol_contentRead()", "InvalidRead",
1300 FatalException, "No child found!");
1301 return;
1302 }
1303 const G4String tag = Transcode(child->getTagName());
1304 if(tag == "parameterised_position_size")
1305 {
1306 ParameterisedRead(child);
1307 }
1308 else if(tag == "loop")
1309 {
1310 LoopRead(child, &G4GDMLRead::Paramvol_contentRead);
1311 }
1312 }
1313 }
1314
1315 // --------------------------------------------------------------------
1316 void G4GDMLReadParamvol::ParamvolRead(const xercesc::DOMElement* const element,
1317 G4LogicalVolume* mother)
1318 {
1319 G4String volumeref;
1320
1321 parameterisation = new G4GDMLParameterisation();
1322 for(xercesc::DOMNode* iter = element->getFirstChild(); iter != nullptr;
1323 iter = iter->getNextSibling())
1324 {
1325 if(iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE)
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::ParamvolRead()", "InvalidRead",
1335 FatalException, "No child found!");
1336 return;
1337 }
1338 const G4String tag = Transcode(child->getTagName());
1339
1340 if(tag == "volumeref")
1341 {
1342 volumeref = RefRead(child);
1343 }
1344 }
1345
1346 Paramvol_contentRead(element);
1347
1348 G4LogicalVolume* logvol = GetVolume(GenerateName(volumeref));
1349
1350 if(parameterisation->GetSize() == 0)
1351 {
1352 G4Exception("G4GDMLReadParamvol::ParamvolRead()", "ReadError",
1353 FatalException,
1354 "No parameters are defined in parameterised volume!");
1355 }
1356 G4String pv_name = logvol->GetName() + "_param";
1357 new G4PVParameterised(pv_name, logvol, mother, kUndefined,
1358 parameterisation->GetSize(), parameterisation, check);
1359 }
1360