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