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