Geant4 Cross Reference |
1 // 1 // 2 // ******************************************* 2 // ******************************************************************** 3 // * License and Disclaimer 3 // * License and Disclaimer * 4 // * 4 // * * 5 // * The Geant4 software is copyright of th 5 // * The Geant4 software is copyright of the Copyright Holders of * 6 // * the Geant4 Collaboration. It is provided 6 // * the Geant4 Collaboration. It is provided under the terms and * 7 // * conditions of the Geant4 Software License 7 // * conditions of the Geant4 Software License, included in the file * 8 // * LICENSE and available at http://cern.ch/ 8 // * LICENSE and available at http://cern.ch/geant4/license . These * 9 // * include a list of copyright holders. 9 // * include a list of copyright holders. * 10 // * 10 // * * 11 // * Neither the authors of this software syst 11 // * Neither the authors of this software system, nor their employing * 12 // * institutes,nor the agencies providing fin 12 // * institutes,nor the agencies providing financial support for this * 13 // * work make any representation or warran 13 // * work make any representation or warranty, express or implied, * 14 // * regarding this software system or assum 14 // * regarding this software system or assume any liability for its * 15 // * use. Please see the license in the file 15 // * use. Please see the license in the file LICENSE and URL above * 16 // * for the full disclaimer and the limitatio 16 // * for the full disclaimer and the limitation of liability. * 17 // * 17 // * * 18 // * This code implementation is the result 18 // * This code implementation is the result of the scientific and * 19 // * technical work of the GEANT4 collaboratio 19 // * technical work of the GEANT4 collaboration. * 20 // * By using, copying, modifying or distri 20 // * By using, copying, modifying or distributing the software (or * 21 // * any work based on the software) you ag 21 // * any work based on the software) you agree to acknowledge its * 22 // * use in resulting scientific publicati 22 // * use in resulting scientific publications, and indicate your * 23 // * acceptance of all terms of the Geant4 Sof 23 // * acceptance of all terms of the Geant4 Software license. * 24 // ******************************************* 24 // ******************************************************************** 25 // 25 // 26 // G4GDMLReadSolids implementation << 26 // $Id: G4GDMLReadSolids.cc 105857 2017-08-24 07:52:24Z gcosmo $ >> 27 // >> 28 // class G4GDMLReadSolids Implementation >> 29 // >> 30 // Original author: Zoltan Torzsok, November 2007 27 // 31 // 28 // Author: Zoltan Torzsok, November 2007 << 29 // ------------------------------------------- 32 // -------------------------------------------------------------------- 30 33 31 #include "G4GDMLReadSolids.hh" 34 #include "G4GDMLReadSolids.hh" 32 #include "G4Box.hh" 35 #include "G4Box.hh" 33 #include "G4Cons.hh" 36 #include "G4Cons.hh" 34 #include "G4Ellipsoid.hh" 37 #include "G4Ellipsoid.hh" 35 #include "G4EllipticalCone.hh" 38 #include "G4EllipticalCone.hh" 36 #include "G4EllipticalTube.hh" 39 #include "G4EllipticalTube.hh" 37 #include "G4Hype.hh" 40 #include "G4Hype.hh" 38 #include "G4IntersectionSolid.hh" 41 #include "G4IntersectionSolid.hh" 39 #include "G4Orb.hh" 42 #include "G4Orb.hh" 40 #include "G4Para.hh" 43 #include "G4Para.hh" 41 #include "G4Paraboloid.hh" 44 #include "G4Paraboloid.hh" 42 #include "G4Polycone.hh" 45 #include "G4Polycone.hh" 43 #include "G4GenericPolycone.hh" 46 #include "G4GenericPolycone.hh" 44 #include "G4Polyhedra.hh" 47 #include "G4Polyhedra.hh" 45 #include "G4QuadrangularFacet.hh" 48 #include "G4QuadrangularFacet.hh" 46 #include "G4ReflectedSolid.hh" 49 #include "G4ReflectedSolid.hh" 47 #include "G4ScaledSolid.hh" 50 #include "G4ScaledSolid.hh" 48 #include "G4Sphere.hh" 51 #include "G4Sphere.hh" 49 #include "G4SolidStore.hh" 52 #include "G4SolidStore.hh" 50 #include "G4SubtractionSolid.hh" 53 #include "G4SubtractionSolid.hh" 51 #include "G4GenericTrap.hh" 54 #include "G4GenericTrap.hh" 52 #include "G4TessellatedSolid.hh" 55 #include "G4TessellatedSolid.hh" 53 #include "G4Tet.hh" 56 #include "G4Tet.hh" 54 #include "G4Torus.hh" 57 #include "G4Torus.hh" 55 #include "G4Transform3D.hh" 58 #include "G4Transform3D.hh" 56 #include "G4Trap.hh" 59 #include "G4Trap.hh" 57 #include "G4Trd.hh" 60 #include "G4Trd.hh" 58 #include "G4TriangularFacet.hh" 61 #include "G4TriangularFacet.hh" 59 #include "G4Tubs.hh" 62 #include "G4Tubs.hh" 60 #include "G4CutTubs.hh" 63 #include "G4CutTubs.hh" 61 #include "G4TwistedBox.hh" 64 #include "G4TwistedBox.hh" 62 #include "G4TwistedTrap.hh" 65 #include "G4TwistedTrap.hh" 63 #include "G4TwistedTrd.hh" 66 #include "G4TwistedTrd.hh" 64 #include "G4TwistedTubs.hh" 67 #include "G4TwistedTubs.hh" 65 #include "G4UnionSolid.hh" 68 #include "G4UnionSolid.hh" 66 #include "G4OpticalSurface.hh" 69 #include "G4OpticalSurface.hh" 67 #include "G4UnitsTable.hh" 70 #include "G4UnitsTable.hh" 68 #include "G4SurfaceProperty.hh" 71 #include "G4SurfaceProperty.hh" >> 72 #include "G4MaterialPropertiesTable.hh" 69 73 70 // ------------------------------------------- << 74 G4GDMLReadSolids::G4GDMLReadSolids() : G4GDMLReadMaterials() 71 G4GDMLReadSolids::G4GDMLReadSolids() << 72 : G4GDMLReadMaterials() << 73 { 75 { 74 } 76 } 75 77 76 // ------------------------------------------- << 77 G4GDMLReadSolids::~G4GDMLReadSolids() 78 G4GDMLReadSolids::~G4GDMLReadSolids() 78 { 79 { 79 } 80 } 80 81 81 // ------------------------------------------- << 82 void G4GDMLReadSolids:: 82 void G4GDMLReadSolids::BooleanRead( << 83 BooleanRead(const xercesc::DOMElement* const booleanElement, const BooleanOp op) 83 const xercesc::DOMElement* const booleanElem << 84 { 84 { 85 G4String name; << 85 G4String name; 86 G4String first; << 86 G4String first; 87 G4String scnd; << 87 G4String scnd; 88 G4ThreeVector position(0.0, 0.0, 0.0); << 88 G4ThreeVector position(0.0,0.0,0.0); 89 G4ThreeVector rotation(0.0, 0.0, 0.0); << 89 G4ThreeVector rotation(0.0,0.0,0.0); 90 G4ThreeVector firstposition(0.0, 0.0, 0.0); << 90 G4ThreeVector firstposition(0.0,0.0,0.0); 91 G4ThreeVector firstrotation(0.0, 0.0, 0.0); << 91 G4ThreeVector firstrotation(0.0,0.0,0.0); 92 << 92 93 const xercesc::DOMNamedNodeMap* const attrib << 93 const xercesc::DOMNamedNodeMap* const attributes 94 booleanElement->getAttributes(); << 94 = booleanElement->getAttributes(); 95 XMLSize_t attributeCount = attributes->getLe << 95 XMLSize_t attributeCount = attributes->getLength(); 96 << 96 97 for(XMLSize_t attribute_index = 0; attribute << 97 for (XMLSize_t attribute_index=0; 98 ++attribute_index) << 98 attribute_index<attributeCount; attribute_index++) 99 { << 99 { 100 xercesc::DOMNode* attribute_node = attribu << 100 xercesc::DOMNode* attribute_node = attributes->item(attribute_index); 101 << 101 102 if(attribute_node->getNodeType() != xerces << 102 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE) 103 { << 103 { continue; } 104 continue; << 104 105 } << 105 const xercesc::DOMAttr* const attribute 106 << 106 = dynamic_cast<xercesc::DOMAttr*>(attribute_node); 107 const xercesc::DOMAttr* const attribute = << 107 if (!attribute) 108 dynamic_cast<xercesc::DOMAttr*>(attribut << 108 { 109 if(attribute == nullptr) << 109 G4Exception("G4GDMLReadSolids::BooleanRead()", 110 { << 110 "InvalidRead", FatalException, "No attribute found!"); 111 G4Exception("G4GDMLReadSolids::BooleanRe << 111 return; 112 FatalException, "No attribut << 112 } 113 return; << 113 const G4String attName = Transcode(attribute->getName()); 114 } << 114 const G4String attValue = Transcode(attribute->getValue()); 115 const G4String attName = Transcode(attrib << 115 116 const G4String attValue = Transcode(attrib << 116 if (attName=="name") { name = GenerateName(attValue); } 117 << 117 } 118 if(attName == "name") << 118 119 { << 119 for (xercesc::DOMNode* iter = booleanElement->getFirstChild(); 120 name = GenerateName(attValue); << 120 iter != 0;iter = iter->getNextSibling()) 121 } << 121 { 122 } << 122 if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE) { continue; } 123 << 123 124 for(xercesc::DOMNode* iter = booleanElement- << 124 const xercesc::DOMElement* const child 125 iter = iter->getNextSi << 125 = dynamic_cast<xercesc::DOMElement*>(iter); 126 { << 126 if (!child) 127 if(iter->getNodeType() != xercesc::DOMNode << 127 { 128 { << 128 G4Exception("G4GDMLReadSolids::BooleanRead()", 129 continue; << 129 "InvalidRead", FatalException, "No child found!"); 130 } << 130 return; 131 << 131 } 132 const xercesc::DOMElement* const child = << 132 const G4String tag = Transcode(child->getTagName()); 133 dynamic_cast<xercesc::DOMElement*>(iter) << 133 134 if(child == nullptr) << 134 if (tag=="first") { first = RefRead(child); } else 135 { << 135 if (tag=="second") { scnd = RefRead(child); } else 136 G4Exception("G4GDMLReadSolids::BooleanRe << 136 if (tag=="position") { VectorRead(child,position); } else 137 FatalException, "No child fo << 137 if (tag=="rotation") { VectorRead(child,rotation); } else 138 return; << 138 if (tag=="positionref") 139 } << 139 { position = GetPosition(GenerateName(RefRead(child))); } else 140 const G4String tag = Transcode(child->getT << 140 if (tag=="rotationref") 141 << 141 { rotation = GetRotation(GenerateName(RefRead(child))); } else 142 if(tag == "first") << 142 if (tag=="firstposition") { VectorRead(child,firstposition); } else 143 { << 143 if (tag=="firstrotation") { VectorRead(child,firstrotation); } else 144 first = RefRead(child); << 144 if (tag=="firstpositionref") 145 } << 145 { firstposition = GetPosition(GenerateName(RefRead(child))); } else 146 else if(tag == "second") << 146 if (tag=="firstrotationref") 147 { << 147 { firstrotation = GetRotation(GenerateName(RefRead(child))); } 148 scnd = RefRead(child); << 148 else 149 } << 149 { 150 else if(tag == "position") << 150 G4String error_msg = "Unknown tag in boolean solid: " + tag; 151 { << 151 G4Exception("G4GDMLReadSolids::BooleanRead()", "ReadError", 152 VectorRead(child, position); << 152 FatalException, error_msg); 153 } << 153 } 154 else if(tag == "rotation") << 154 } 155 { << 155 156 VectorRead(child, rotation); << 156 G4VSolid* firstSolid = GetSolid(GenerateName(first)); 157 } << 157 G4VSolid* secondSolid = GetSolid(GenerateName(scnd)); 158 else if(tag == "positionref") << 158 159 { << 159 G4Transform3D transform(GetRotationMatrix(rotation),position); 160 position = GetPosition(GenerateName(RefR << 160 161 } << 161 if (( (firstrotation.x()!=0.0) || (firstrotation.y()!=0.0) 162 else if(tag == "rotationref") << 162 || (firstrotation.z()!=0.0)) 163 { << 163 || ( (firstposition.x()!=0.0) || (firstposition.y()!=0.0) 164 rotation = GetRotation(GenerateName(RefR << 164 || (firstposition.z()!=0.0))) 165 } << 165 { 166 else if(tag == "firstposition") << 166 G4Transform3D firsttransform(GetRotationMatrix(firstrotation), 167 { << 167 firstposition); 168 VectorRead(child, firstposition); << 168 firstSolid = new G4DisplacedSolid(GenerateName("displaced_"+first), 169 } << 169 firstSolid, firsttransform); 170 else if(tag == "firstrotation") << 170 } 171 { << 171 172 VectorRead(child, firstrotation); << 172 if (op==UNION) 173 } << 173 { new G4UnionSolid(name,firstSolid,secondSolid,transform); } else 174 else if(tag == "firstpositionref") << 174 if (op==SUBTRACTION) 175 { << 175 { new G4SubtractionSolid(name,firstSolid,secondSolid,transform); } else 176 firstposition = GetPosition(GenerateName << 176 if (op==INTERSECTION) 177 } << 177 { new G4IntersectionSolid(name,firstSolid,secondSolid,transform); } 178 else if(tag == "firstrotationref") << 179 { << 180 firstrotation = GetRotation(GenerateName << 181 } << 182 else << 183 { << 184 G4String error_msg = "Unknown tag in boo << 185 G4Exception("G4GDMLReadSolids::BooleanRe << 186 FatalException, error_msg); << 187 } << 188 } << 189 << 190 G4VSolid* firstSolid = GetSolid(GenerateNam << 191 G4VSolid* secondSolid = GetSolid(GenerateNam << 192 << 193 G4Transform3D transform(GetRotationMatrix(ro << 194 << 195 if(((firstrotation.x() != 0.0) || (firstrota << 196 (firstrotation.z() != 0.0)) || << 197 ((firstposition.x() != 0.0) || (firstposi << 198 (firstposition.z() != 0.0))) << 199 { << 200 G4Transform3D firsttransform(GetRotationMa << 201 firstposition << 202 firstSolid = new G4DisplacedSolid(Generate << 203 firstSol << 204 } << 205 << 206 if(op == UNION) << 207 { << 208 new G4UnionSolid(name, firstSolid, secondS << 209 } << 210 else if(op == SUBTRACTION) << 211 { << 212 new G4SubtractionSolid(name, firstSolid, s << 213 } << 214 else if(op == INTERSECTION) << 215 { << 216 new G4IntersectionSolid(name, firstSolid, << 217 } << 218 } 178 } 219 179 220 // ------------------------------------------- << 221 void G4GDMLReadSolids::BoxRead(const xercesc:: 180 void G4GDMLReadSolids::BoxRead(const xercesc::DOMElement* const boxElement) 222 { 181 { 223 G4String name; << 182 G4String name; 224 G4double lunit = 1.0; << 183 G4double lunit = 1.0; 225 G4double x = 0.0; << 184 G4double x = 0.0; 226 G4double y = 0.0; << 185 G4double y = 0.0; 227 G4double z = 0.0; << 186 G4double z = 0.0; 228 << 187 229 const xercesc::DOMNamedNodeMap* const attrib << 188 const xercesc::DOMNamedNodeMap* const attributes 230 boxElement->getAttributes(); << 189 = boxElement->getAttributes(); 231 XMLSize_t attributeCount = attributes->getLe << 190 XMLSize_t attributeCount = attributes->getLength(); 232 << 191 233 for(XMLSize_t attribute_index = 0; attribute << 192 for (XMLSize_t attribute_index=0; 234 ++attribute_index) << 193 attribute_index<attributeCount; attribute_index++) 235 { << 194 { 236 xercesc::DOMNode* attribute_node = attribu << 195 xercesc::DOMNode* attribute_node = attributes->item(attribute_index); 237 << 196 238 if(attribute_node->getNodeType() != xerces << 197 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE) 239 { << 198 { continue; } 240 continue; << 199 241 } << 200 const xercesc::DOMAttr* const attribute 242 << 201 = dynamic_cast<xercesc::DOMAttr*>(attribute_node); 243 const xercesc::DOMAttr* const attribute = << 202 if (!attribute) 244 dynamic_cast<xercesc::DOMAttr*>(attribut << 203 { 245 if(attribute == nullptr) << 204 G4Exception("G4GDMLReadSolids::BoxRead()", 246 { << 205 "InvalidRead", FatalException, "No attribute found!"); 247 G4Exception("G4GDMLReadSolids::BoxRead() << 206 return; 248 "No attribute found!"); << 207 } 249 return; << 208 const G4String attName = Transcode(attribute->getName()); 250 } << 209 const G4String attValue = Transcode(attribute->getValue()); 251 const G4String attName = Transcode(attrib << 210 252 const G4String attValue = Transcode(attrib << 211 if (attName=="name") { name = GenerateName(attValue); } else 253 << 212 if (attName=="lunit") { lunit = G4UnitDefinition::GetValueOf(attValue); 254 if(attName == "name") << 213 if (G4UnitDefinition::GetCategory(attValue)!="Length") { 255 { << 214 G4Exception("G4GDMLReadSolids::BoxRead()", "InvalidRead", 256 name = GenerateName(attValue); << 215 FatalException, "Invalid unit for length!"); } 257 } << 216 } 258 else if(attName == "lunit") << 217 else 259 { << 218 if (attName=="x") { x = eval.Evaluate(attValue); } else 260 lunit = G4UnitDefinition::GetValueOf(att << 219 if (attName=="y") { y = eval.Evaluate(attValue); } else 261 if(G4UnitDefinition::GetCategory(attValu << 220 if (attName=="z") { z = eval.Evaluate(attValue); } 262 { << 221 } 263 G4Exception("G4GDMLReadSolids::BoxRead << 222 264 FatalException, "Invalid u << 223 x *= 0.5*lunit; 265 } << 224 y *= 0.5*lunit; 266 } << 225 z *= 0.5*lunit; 267 else if(attName == "x") << 268 { << 269 x = eval.Evaluate(attValue); << 270 } << 271 else if(attName == "y") << 272 { << 273 y = eval.Evaluate(attValue); << 274 } << 275 else if(attName == "z") << 276 { << 277 z = eval.Evaluate(attValue); << 278 } << 279 } << 280 << 281 x *= 0.5 * lunit; << 282 y *= 0.5 * lunit; << 283 z *= 0.5 * lunit; << 284 226 285 new G4Box(name, x, y, z); << 227 new G4Box(name,x,y,z); 286 } 228 } 287 229 288 // ------------------------------------------- << 289 void G4GDMLReadSolids::ConeRead(const xercesc: 230 void G4GDMLReadSolids::ConeRead(const xercesc::DOMElement* const coneElement) 290 { 231 { 291 G4String name; << 232 G4String name; 292 G4double lunit = 1.0; << 233 G4double lunit = 1.0; 293 G4double aunit = 1.0; << 234 G4double aunit = 1.0; 294 G4double rmin1 = 0.0; << 235 G4double rmin1 = 0.0; 295 G4double rmax1 = 0.0; << 236 G4double rmax1 = 0.0; 296 G4double rmin2 = 0.0; << 237 G4double rmin2 = 0.0; 297 G4double rmax2 = 0.0; << 238 G4double rmax2 = 0.0; 298 G4double z = 0.0; << 239 G4double z = 0.0; 299 G4double startphi = 0.0; << 240 G4double startphi = 0.0; 300 G4double deltaphi = 0.0; << 241 G4double deltaphi = 0.0; 301 << 242 302 const xercesc::DOMNamedNodeMap* const attrib << 243 const xercesc::DOMNamedNodeMap* const attributes 303 coneElement->getAttributes(); << 244 = coneElement->getAttributes(); 304 XMLSize_t attributeCount = attributes->getLe << 245 XMLSize_t attributeCount = attributes->getLength(); 305 << 246 306 for(XMLSize_t attribute_index = 0; attribute << 247 for (XMLSize_t attribute_index=0; 307 ++attribute_index) << 248 attribute_index<attributeCount; attribute_index++) 308 { << 249 { 309 xercesc::DOMNode* attribute_node = attribu << 250 xercesc::DOMNode* attribute_node = attributes->item(attribute_index); 310 << 251 311 if(attribute_node->getNodeType() != xerces << 252 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE) 312 { << 253 { continue; } 313 continue; << 254 314 } << 255 const xercesc::DOMAttr* const attribute 315 << 256 = dynamic_cast<xercesc::DOMAttr*>(attribute_node); 316 const xercesc::DOMAttr* const attribute = << 257 if (!attribute) 317 dynamic_cast<xercesc::DOMAttr*>(attribut << 258 { 318 if(attribute == nullptr) << 259 G4Exception("G4GDMLReadSolids::ConeRead()", 319 { << 260 "InvalidRead", FatalException, "No attribute found!"); 320 G4Exception("G4GDMLReadSolids::ConeRead( << 261 return; 321 "No attribute found!"); << 262 } 322 return; << 263 const G4String attName = Transcode(attribute->getName()); 323 } << 264 const G4String attValue = Transcode(attribute->getValue()); 324 const G4String attName = Transcode(attrib << 265 325 const G4String attValue = Transcode(attrib << 266 if (attName=="name") { name = GenerateName(attValue); } else 326 << 267 if (attName=="lunit") { lunit = G4UnitDefinition::GetValueOf(attValue); 327 if(attName == "name") << 268 if (G4UnitDefinition::GetCategory(attValue)!="Length") { 328 { << 269 G4Exception("G4GDMLReadSolids::ConeRead()", "InvalidRead", 329 name = GenerateName(attValue); << 270 FatalException, "Invalid unit for length!"); } 330 } << 271 } else 331 else if(attName == "lunit") << 272 if (attName=="aunit") { aunit = G4UnitDefinition::GetValueOf(attValue); 332 { << 273 if (G4UnitDefinition::GetCategory(attValue)!="Angle") { 333 lunit = G4UnitDefinition::GetValueOf(att << 274 G4Exception("G4GDMLReadSolids::ConeRead()", "InvalidRead", 334 if(G4UnitDefinition::GetCategory(attValu << 275 FatalException, "Invalid unit for angle!"); } 335 { << 276 } else 336 G4Exception("G4GDMLReadSolids::ConeRea << 277 if (attName=="rmin1") { rmin1 = eval.Evaluate(attValue); } else 337 FatalException, "Invalid u << 278 if (attName=="rmax1") { rmax1 = eval.Evaluate(attValue); } else 338 } << 279 if (attName=="rmin2") { rmin2 = eval.Evaluate(attValue); } else 339 } << 280 if (attName=="rmax2") { rmax2 = eval.Evaluate(attValue); } else 340 else if(attName == "aunit") << 281 if (attName=="z") { z = eval.Evaluate(attValue); } else 341 { << 282 if (attName=="startphi") { startphi = eval.Evaluate(attValue); } else 342 aunit = G4UnitDefinition::GetValueOf(att << 283 if (attName=="deltaphi") { deltaphi = eval.Evaluate(attValue); } 343 if(G4UnitDefinition::GetCategory(attValu << 284 } 344 { << 285 345 G4Exception("G4GDMLReadSolids::ConeRea << 286 rmin1 *= lunit; 346 FatalException, "Invalid u << 287 rmax1 *= lunit; 347 } << 288 rmin2 *= lunit; 348 } << 289 rmax2 *= lunit; 349 else if(attName == "rmin1") << 290 z *= 0.5*lunit; 350 { << 291 startphi *= aunit; 351 rmin1 = eval.Evaluate(attValue); << 292 deltaphi *= aunit; 352 } << 293 353 else if(attName == "rmax1") << 294 new G4Cons(name,rmin1,rmax1,rmin2,rmax2,z,startphi,deltaphi); 354 { << 295 } 355 rmax1 = eval.Evaluate(attValue); << 296 356 } << 297 void G4GDMLReadSolids:: 357 else if(attName == "rmin2") << 298 ElconeRead(const xercesc::DOMElement* const elconeElement) 358 { << 299 { 359 rmin2 = eval.Evaluate(attValue); << 300 G4String name; 360 } << 301 G4double lunit = 1.0; 361 else if(attName == "rmax2") << 302 G4double dx = 0.0; 362 { << 303 G4double dy = 0.0; 363 rmax2 = eval.Evaluate(attValue); << 304 G4double zmax = 0.0; 364 } << 305 G4double zcut = 0.0; 365 else if(attName == "z") << 306 366 { << 307 const xercesc::DOMNamedNodeMap* const attributes 367 z = eval.Evaluate(attValue); << 308 = elconeElement->getAttributes(); 368 } << 309 XMLSize_t attributeCount = attributes->getLength(); 369 else if(attName == "startphi") << 310 370 { << 311 for (XMLSize_t attribute_index=0; 371 startphi = eval.Evaluate(attValue); << 312 attribute_index<attributeCount; attribute_index++) 372 } << 313 { 373 else if(attName == "deltaphi") << 314 xercesc::DOMNode* attribute_node = attributes->item(attribute_index); 374 { << 315 375 deltaphi = eval.Evaluate(attValue); << 316 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE) 376 } << 317 { continue; } 377 } << 318 378 << 319 const xercesc::DOMAttr* const attribute 379 rmin1 *= lunit; << 320 = dynamic_cast<xercesc::DOMAttr*>(attribute_node); 380 rmax1 *= lunit; << 321 if (!attribute) 381 rmin2 *= lunit; << 322 { 382 rmax2 *= lunit; << 323 G4Exception("G4GDMLReadSolids::ElconeRead()", 383 z *= 0.5 * lunit; << 324 "InvalidRead", FatalException, "No attribute found!"); 384 startphi *= aunit; << 325 return; 385 deltaphi *= aunit; << 326 } 386 << 327 const G4String attName = Transcode(attribute->getName()); 387 new G4Cons(name, rmin1, rmax1, rmin2, rmax2, << 328 const G4String attValue = Transcode(attribute->getValue()); 388 } << 329 389 << 330 if (attName=="name") { name = GenerateName(attValue); } else 390 // ------------------------------------------- << 331 if (attName=="lunit") { lunit = G4UnitDefinition::GetValueOf(attValue); 391 void G4GDMLReadSolids::ElconeRead( << 332 if (G4UnitDefinition::GetCategory(attValue)!="Length") { 392 const xercesc::DOMElement* const elconeEleme << 333 G4Exception("G4GDMLReadSolids::ElconeRead()", "InvalidRead", 393 { << 334 FatalException, "Invalid unit for length!"); } 394 G4String name; << 335 } else 395 G4double lunit = 1.0; << 336 if (attName=="dx") { dx = eval.Evaluate(attValue); } else 396 G4double dx = 0.0; << 337 if (attName=="dy") { dy = eval.Evaluate(attValue); } else 397 G4double dy = 0.0; << 338 if (attName=="zmax") { zmax = eval.Evaluate(attValue); } else 398 G4double zmax = 0.0; << 339 if (attName=="zcut") { zcut = eval.Evaluate(attValue); } 399 G4double zcut = 0.0; << 340 } 400 << 341 401 const xercesc::DOMNamedNodeMap* const attrib << 342 zmax *= lunit; 402 elconeElement->getAttributes(); << 343 zcut *= lunit; 403 XMLSize_t attributeCount = attributes->getLe << 344 404 << 345 new G4EllipticalCone(name,dx,dy,zmax,zcut); 405 for(XMLSize_t attribute_index = 0; attribute << 346 } 406 ++attribute_index) << 347 407 { << 348 void G4GDMLReadSolids:: 408 xercesc::DOMNode* attribute_node = attribu << 349 EllipsoidRead(const xercesc::DOMElement* const ellipsoidElement) 409 << 350 { 410 if(attribute_node->getNodeType() != xerces << 351 G4String name; 411 { << 352 G4double lunit = 1.0; 412 continue; << 353 G4double ax = 0.0; 413 } << 354 G4double by = 0.0; 414 << 355 G4double cz = 0.0; 415 const xercesc::DOMAttr* const attribute = << 356 G4double zcut1 = 0.0; 416 dynamic_cast<xercesc::DOMAttr*>(attribut << 357 G4double zcut2 = 0.0; 417 if(attribute == nullptr) << 358 418 { << 359 const xercesc::DOMNamedNodeMap* const attributes 419 G4Exception("G4GDMLReadSolids::ElconeRea << 360 = ellipsoidElement->getAttributes(); 420 FatalException, "No attribut << 361 XMLSize_t attributeCount = attributes->getLength(); 421 return; << 362 422 } << 363 for (XMLSize_t attribute_index=0; 423 const G4String attName = Transcode(attrib << 364 attribute_index<attributeCount; attribute_index++) 424 const G4String attValue = Transcode(attrib << 365 { 425 << 366 xercesc::DOMNode* attribute_node = attributes->item(attribute_index); 426 if(attName == "name") << 367 427 { << 368 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE) 428 name = GenerateName(attValue); << 369 { continue; } 429 } << 370 430 else if(attName == "lunit") << 371 const xercesc::DOMAttr* const attribute 431 { << 372 = dynamic_cast<xercesc::DOMAttr*>(attribute_node); 432 lunit = G4UnitDefinition::GetValueOf(att << 373 if (!attribute) 433 if(G4UnitDefinition::GetCategory(attValu << 374 { 434 { << 375 G4Exception("G4GDMLReadSolids::EllipsoidRead()", 435 G4Exception("G4GDMLReadSolids::ElconeR << 376 "InvalidRead", FatalException, "No attribute found!"); 436 FatalException, "Invalid u << 377 return; 437 } << 378 } 438 } << 379 const G4String attName = Transcode(attribute->getName()); 439 else if(attName == "dx") << 380 const G4String attValue = Transcode(attribute->getValue()); 440 { << 381 441 dx = eval.Evaluate(attValue); << 382 if (attName=="name") { name = GenerateName(attValue); } else 442 } << 383 if (attName=="lunit") { lunit = G4UnitDefinition::GetValueOf(attValue); 443 else if(attName == "dy") << 384 if (G4UnitDefinition::GetCategory(attValue)!="Length") { 444 { << 385 G4Exception("G4GDMLReadSolids::EllipsoidRead()", "InvalidRead", 445 dy = eval.Evaluate(attValue); << 386 FatalException, "Invalid unit for length!"); } 446 } << 387 } else 447 else if(attName == "zmax") << 388 if (attName=="ax") { ax = eval.Evaluate(attValue); } else 448 { << 389 if (attName=="by") { by = eval.Evaluate(attValue); } else 449 zmax = eval.Evaluate(attValue); << 390 if (attName=="cz") { cz = eval.Evaluate(attValue); } else 450 } << 391 if (attName=="zcut1") { zcut1 = eval.Evaluate(attValue); } else 451 else if(attName == "zcut") << 392 if (attName=="zcut2") { zcut2 = eval.Evaluate(attValue); } 452 { << 393 } 453 zcut = eval.Evaluate(attValue); << 394 454 } << 395 ax *= lunit; 455 } << 396 by *= lunit; 456 << 397 cz *= lunit; 457 zmax *= lunit; << 398 zcut1 *= lunit; 458 zcut *= lunit; << 399 zcut2 *= lunit; >> 400 >> 401 new G4Ellipsoid(name,ax,by,cz,zcut1,zcut2); >> 402 } >> 403 >> 404 void G4GDMLReadSolids:: >> 405 EltubeRead(const xercesc::DOMElement* const eltubeElement) >> 406 { >> 407 G4String name; >> 408 G4double lunit = 1.0; >> 409 G4double dx = 0.0; >> 410 G4double dy = 0.0; >> 411 G4double dz = 0.0; >> 412 >> 413 const xercesc::DOMNamedNodeMap* const attributes >> 414 = eltubeElement->getAttributes(); >> 415 XMLSize_t attributeCount = attributes->getLength(); >> 416 >> 417 for (XMLSize_t attribute_index=0; >> 418 attribute_index<attributeCount; attribute_index++) >> 419 { >> 420 xercesc::DOMNode* attribute_node = attributes->item(attribute_index); >> 421 >> 422 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE) >> 423 { continue; } >> 424 >> 425 const xercesc::DOMAttr* const attribute >> 426 = dynamic_cast<xercesc::DOMAttr*>(attribute_node); >> 427 if (!attribute) >> 428 { >> 429 G4Exception("G4GDMLReadSolids::EltubeRead()", >> 430 "InvalidRead", FatalException, "No attribute found!"); >> 431 return; >> 432 } >> 433 const G4String attName = Transcode(attribute->getName()); >> 434 const G4String attValue = Transcode(attribute->getValue()); >> 435 >> 436 if (attName=="name") { name = GenerateName(attValue); } else >> 437 if (attName=="lunit") { lunit = G4UnitDefinition::GetValueOf(attValue); >> 438 if (G4UnitDefinition::GetCategory(attValue)!="Length") { >> 439 G4Exception("G4GDMLReadSolids::EltubeRead()", "InvalidRead", >> 440 FatalException, "Invalid unit for length!"); } >> 441 } else >> 442 if (attName=="dx") { dx = eval.Evaluate(attValue); } else >> 443 if (attName=="dy") { dy = eval.Evaluate(attValue); } else >> 444 if (attName=="dz") { dz = eval.Evaluate(attValue); } >> 445 } >> 446 >> 447 dx *= lunit; >> 448 dy *= lunit; >> 449 dz *= lunit; 459 450 460 new G4EllipticalCone(name, dx, dy, zmax, zcu << 451 new G4EllipticalTube(name,dx,dy,dz); 461 } 452 } 462 453 463 // ------------------------------------------- << 464 void G4GDMLReadSolids::EllipsoidRead( << 465 const xercesc::DOMElement* const ellipsoidEl << 466 { << 467 G4String name; << 468 G4double lunit = 1.0; << 469 G4double ax = 0.0; << 470 G4double by = 0.0; << 471 G4double cz = 0.0; << 472 G4double zcut1 = 0.0; << 473 G4double zcut2 = 0.0; << 474 << 475 const xercesc::DOMNamedNodeMap* const attrib << 476 ellipsoidElement->getAttributes(); << 477 XMLSize_t attributeCount = attributes->getLe << 478 << 479 for(XMLSize_t attribute_index = 0; attribute << 480 ++attribute_index) << 481 { << 482 xercesc::DOMNode* attribute_node = attribu << 483 << 484 if(attribute_node->getNodeType() != xerces << 485 { << 486 continue; << 487 } << 488 << 489 const xercesc::DOMAttr* const attribute = << 490 dynamic_cast<xercesc::DOMAttr*>(attribut << 491 if(attribute == nullptr) << 492 { << 493 G4Exception("G4GDMLReadSolids::Ellipsoid << 494 FatalException, "No attribut << 495 return; << 496 } << 497 const G4String attName = Transcode(attrib << 498 const G4String attValue = Transcode(attrib << 499 << 500 if(attName == "name") << 501 { << 502 name = GenerateName(attValue); << 503 } << 504 else if(attName == "lunit") << 505 { << 506 lunit = G4UnitDefinition::GetValueOf(att << 507 if(G4UnitDefinition::GetCategory(attValu << 508 { << 509 G4Exception("G4GDMLReadSolids::Ellipso << 510 FatalException, "Invalid u << 511 } << 512 } << 513 else if(attName == "ax") << 514 { << 515 ax = eval.Evaluate(attValue); << 516 } << 517 else if(attName == "by") << 518 { << 519 by = eval.Evaluate(attValue); << 520 } << 521 else if(attName == "cz") << 522 { << 523 cz = eval.Evaluate(attValue); << 524 } << 525 else if(attName == "zcut1") << 526 { << 527 zcut1 = eval.Evaluate(attValue); << 528 } << 529 else if(attName == "zcut2") << 530 { << 531 zcut2 = eval.Evaluate(attValue); << 532 } << 533 } << 534 << 535 ax *= lunit; << 536 by *= lunit; << 537 cz *= lunit; << 538 zcut1 *= lunit; << 539 zcut2 *= lunit; << 540 << 541 new G4Ellipsoid(name, ax, by, cz, zcut1, zcu << 542 } << 543 << 544 // ------------------------------------------- << 545 void G4GDMLReadSolids::EltubeRead( << 546 const xercesc::DOMElement* const eltubeEleme << 547 { << 548 G4String name; << 549 G4double lunit = 1.0; << 550 G4double dx = 0.0; << 551 G4double dy = 0.0; << 552 G4double dz = 0.0; << 553 << 554 const xercesc::DOMNamedNodeMap* const attrib << 555 eltubeElement->getAttributes(); << 556 XMLSize_t attributeCount = attributes->getLe << 557 << 558 for(XMLSize_t attribute_index = 0; attribute << 559 ++attribute_index) << 560 { << 561 xercesc::DOMNode* attribute_node = attribu << 562 << 563 if(attribute_node->getNodeType() != xerces << 564 { << 565 continue; << 566 } << 567 << 568 const xercesc::DOMAttr* const attribute = << 569 dynamic_cast<xercesc::DOMAttr*>(attribut << 570 if(attribute == nullptr) << 571 { << 572 G4Exception("G4GDMLReadSolids::EltubeRea << 573 FatalException, "No attribut << 574 return; << 575 } << 576 const G4String attName = Transcode(attrib << 577 const G4String attValue = Transcode(attrib << 578 << 579 if(attName == "name") << 580 { << 581 name = GenerateName(attValue); << 582 } << 583 else if(attName == "lunit") << 584 { << 585 lunit = G4UnitDefinition::GetValueOf(att << 586 if(G4UnitDefinition::GetCategory(attValu << 587 { << 588 G4Exception("G4GDMLReadSolids::EltubeR << 589 FatalException, "Invalid u << 590 } << 591 } << 592 else if(attName == "dx") << 593 { << 594 dx = eval.Evaluate(attValue); << 595 } << 596 else if(attName == "dy") << 597 { << 598 dy = eval.Evaluate(attValue); << 599 } << 600 else if(attName == "dz") << 601 { << 602 dz = eval.Evaluate(attValue); << 603 } << 604 } << 605 << 606 dx *= lunit; << 607 dy *= lunit; << 608 dz *= lunit; << 609 << 610 new G4EllipticalTube(name, dx, dy, dz); << 611 } << 612 << 613 // ------------------------------------------- << 614 void G4GDMLReadSolids::XtruRead(const xercesc: 454 void G4GDMLReadSolids::XtruRead(const xercesc::DOMElement* const xtruElement) 615 { 455 { 616 G4String name; << 456 G4String name; 617 G4double lunit = 1.0; << 457 G4double lunit = 1.0; 618 << 619 const xercesc::DOMNamedNodeMap* const attrib << 620 xtruElement->getAttributes(); << 621 XMLSize_t attributeCount = attributes->getLe << 622 << 623 for(XMLSize_t attribute_index = 0; attribute << 624 ++attribute_index) << 625 { << 626 xercesc::DOMNode* attribute_node = attribu << 627 << 628 if(attribute_node->getNodeType() != xerces << 629 { << 630 continue; << 631 } << 632 << 633 const xercesc::DOMAttr* const attribute = << 634 dynamic_cast<xercesc::DOMAttr*>(attribut << 635 if(attribute == nullptr) << 636 { << 637 G4Exception("G4GDMLReadSolids::XtruRead( << 638 "No attribute found!"); << 639 return; << 640 } << 641 const G4String attName = Transcode(attrib << 642 const G4String attValue = Transcode(attrib << 643 << 644 if(attName == "name") << 645 { << 646 name = GenerateName(attValue); << 647 } << 648 else if(attName == "lunit") << 649 { << 650 lunit = G4UnitDefinition::GetValueOf(att << 651 if(G4UnitDefinition::GetCategory(attValu << 652 { << 653 G4Exception("G4GDMLReadSolids::XtruRea << 654 FatalException, "Invalid u << 655 } << 656 } << 657 } << 658 << 659 std::vector<G4TwoVector> twoDimVertexList; << 660 std::vector<G4ExtrudedSolid::ZSection> secti << 661 << 662 for(xercesc::DOMNode* iter = xtruElement->ge << 663 iter = iter->getNextSi << 664 { << 665 if(iter->getNodeType() != xercesc::DOMNode << 666 { << 667 continue; << 668 } << 669 << 670 const xercesc::DOMElement* const child = << 671 dynamic_cast<xercesc::DOMElement*>(iter) << 672 if(child == nullptr) << 673 { << 674 G4Exception("G4GDMLReadSolids::XtruRead( << 675 "No child found!"); << 676 return; << 677 } << 678 const G4String tag = Transcode(child->getT << 679 << 680 if(tag == "twoDimVertex") << 681 { << 682 twoDimVertexList.push_back(TwoDimVertexR << 683 } << 684 else if(tag == "section") << 685 { << 686 sectionList.push_back(SectionRead(child, << 687 } << 688 } << 689 << 690 new G4ExtrudedSolid(name, twoDimVertexList, << 691 } << 692 << 693 // ------------------------------------------- << 694 void G4GDMLReadSolids::HypeRead(const xercesc: << 695 { << 696 G4String name; << 697 G4double lunit = 1.0; << 698 G4double aunit = 1.0; << 699 G4double rmin = 0.0; << 700 G4double rmax = 0.0; << 701 G4double inst = 0.0; << 702 G4double outst = 0.0; << 703 G4double z = 0.0; << 704 << 705 const xercesc::DOMNamedNodeMap* const attrib << 706 hypeElement->getAttributes(); << 707 XMLSize_t attributeCount = attributes->getLe << 708 << 709 for(XMLSize_t attribute_index = 0; attribute << 710 ++attribute_index) << 711 { << 712 xercesc::DOMNode* attribute_node = attribu << 713 << 714 if(attribute_node->getNodeType() != xerces << 715 { << 716 continue; << 717 } << 718 << 719 const xercesc::DOMAttr* const attribute = << 720 dynamic_cast<xercesc::DOMAttr*>(attribut << 721 if(attribute == nullptr) << 722 { << 723 G4Exception("G4GDMLReadSolids::HypeRead( << 724 "No attribute found!"); << 725 return; << 726 } << 727 const G4String attName = Transcode(attrib << 728 const G4String attValue = Transcode(attrib << 729 << 730 if(attName == "name") << 731 { << 732 name = GenerateName(attValue); << 733 } << 734 else if(attName == "lunit") << 735 { << 736 lunit = G4UnitDefinition::GetValueOf(att << 737 if(G4UnitDefinition::GetCategory(attValu << 738 { << 739 G4Exception("G4GDMLReadSolids::HypeRea << 740 FatalException, "Invalid u << 741 } << 742 } << 743 else if(attName == "aunit") << 744 { << 745 aunit = G4UnitDefinition::GetValueOf(att << 746 if(G4UnitDefinition::GetCategory(attValu << 747 { << 748 G4Exception("G4GDMLReadSolids::HypeRea << 749 FatalException, "Invalid u << 750 } << 751 } << 752 else if(attName == "rmin") << 753 { << 754 rmin = eval.Evaluate(attValue); << 755 } << 756 else if(attName == "rmax") << 757 { << 758 rmax = eval.Evaluate(attValue); << 759 } << 760 else if(attName == "inst") << 761 { << 762 inst = eval.Evaluate(attValue); << 763 } << 764 else if(attName == "outst") << 765 { << 766 outst = eval.Evaluate(attValue); << 767 } << 768 else if(attName == "z") << 769 { << 770 z = eval.Evaluate(attValue); << 771 } << 772 } << 773 << 774 rmin *= lunit; << 775 rmax *= lunit; << 776 inst *= aunit; << 777 outst *= aunit; << 778 z *= 0.5 * lunit; << 779 << 780 new G4Hype(name, rmin, rmax, inst, outst, z) << 781 } << 782 << 783 // ------------------------------------------- << 784 void G4GDMLReadSolids::MultiUnionNodeRead( << 785 const xercesc::DOMElement* const unionNodeEl << 786 G4MultiUnion* const multiUnionSolid) << 787 { << 788 G4String name; << 789 G4String solid; << 790 G4ThreeVector position(0.0, 0.0, 0.0); << 791 G4ThreeVector rotation(0.0, 0.0, 0.0); << 792 << 793 const xercesc::DOMNamedNodeMap* const attrib << 794 unionNodeElement->getAttributes(); << 795 XMLSize_t attributeCount = attributes->getLe << 796 << 797 for(XMLSize_t attribute_index = 0; attribute << 798 ++attribute_index) << 799 { << 800 xercesc::DOMNode* attribute_node = attribu << 801 << 802 if(attribute_node->getNodeType() != xerces << 803 { << 804 continue; << 805 } << 806 << 807 const xercesc::DOMAttr* const attribute = << 808 dynamic_cast<xercesc::DOMAttr*>(attribut << 809 if(attribute == nullptr) << 810 { << 811 G4Exception("G4GDMLReadSolids::MultiUnio << 812 FatalException, "No attribut << 813 return; << 814 } << 815 const G4String attName = Transcode(attrib << 816 const G4String attValue = Transcode(attrib << 817 << 818 if(attName == "name") << 819 { << 820 name = GenerateName(attValue); << 821 } << 822 } << 823 << 824 for(xercesc::DOMNode* iter = unionNodeElemen << 825 iter != nullptr; iter << 826 { << 827 if(iter->getNodeType() != xercesc::DOMNode << 828 { << 829 continue; << 830 } << 831 << 832 const xercesc::DOMElement* const child = << 833 dynamic_cast<xercesc::DOMElement*>(iter) << 834 if(child == nullptr) << 835 { << 836 G4Exception("G4GDMLReadSolids::MultiUnio << 837 FatalException, "No child fo << 838 return; << 839 } << 840 const G4String tag = Transcode(child->getT << 841 << 842 if(tag == "position") << 843 { << 844 VectorRead(child, position); << 845 } << 846 else if(tag == "rotation") << 847 { << 848 VectorRead(child, rotation); << 849 } << 850 else if(tag == "positionref") << 851 { << 852 position = GetPosition(GenerateName(RefR << 853 } << 854 else if(tag == "rotationref") << 855 { << 856 rotation = GetRotation(GenerateName(RefR << 857 } << 858 else if(tag == "solid") << 859 { << 860 solid = RefRead(child); << 861 } << 862 else << 863 { << 864 G4String error_msg = "Unknown tag in Mul << 865 G4Exception("G4GDMLReadSolids::MultiUnio << 866 FatalException, error_msg); << 867 } << 868 } << 869 G4VSolid* solidNode = GetSolid(GenerateName( << 870 G4Transform3D transform(GetRotationMatrix(ro << 871 multiUnionSolid->AddNode(*solidNode, transfo << 872 } << 873 << 874 // ------------------------------------------- << 875 void G4GDMLReadSolids::MultiUnionRead( << 876 const xercesc::DOMElement* const unionElemen << 877 { << 878 G4String name; << 879 << 880 const xercesc::DOMNamedNodeMap* const attrib << 881 unionElement->getAttributes(); << 882 XMLSize_t attributeCount = attributes->getLe << 883 << 884 for(XMLSize_t attribute_index = 0; attribute << 885 ++attribute_index) << 886 { << 887 xercesc::DOMNode* attribute_node = attribu << 888 << 889 if(attribute_node->getNodeType() != xerces << 890 { << 891 continue; << 892 } << 893 << 894 const xercesc::DOMAttr* const attribute = << 895 dynamic_cast<xercesc::DOMAttr*>(attribut << 896 if(attribute == nullptr) << 897 { << 898 G4Exception("G4GDMLReadSolids::MultiUnio << 899 FatalException, "No attribut << 900 return; << 901 } << 902 const G4String attName = Transcode(attrib << 903 const G4String attValue = Transcode(attrib << 904 << 905 if(attName == "name") << 906 { << 907 name = GenerateName(attValue); << 908 } << 909 } << 910 << 911 G4MultiUnion* multiUnion = new G4MultiUnion( << 912 << 913 for(xercesc::DOMNode* iter = unionElement->g << 914 iter = iter->getNextSi << 915 { << 916 if(iter->getNodeType() != xercesc::DOMNode << 917 { << 918 continue; << 919 } << 920 << 921 const xercesc::DOMElement* const child = << 922 dynamic_cast<xercesc::DOMElement*>(iter) << 923 if(child == nullptr) << 924 { << 925 G4Exception("G4GDMLReadSolids::MultiUnio << 926 FatalException, "No child fo << 927 return; << 928 } << 929 const G4String tag = Transcode(child->getT << 930 << 931 if(tag == "multiUnionNode") << 932 { << 933 MultiUnionNodeRead(child, multiUnion); << 934 } << 935 else << 936 { << 937 G4String error_msg = "Unknown tag in Mul << 938 G4Exception("G4GDMLReadSolids::MultiUnio << 939 FatalException, error_msg); << 940 } << 941 } << 942 multiUnion->Voxelize(); << 943 } << 944 << 945 // ------------------------------------------- << 946 void G4GDMLReadSolids::OrbRead(const xercesc:: << 947 { << 948 G4String name; << 949 G4double lunit = 1.0; << 950 G4double r = 0.0; << 951 << 952 const xercesc::DOMNamedNodeMap* const attrib << 953 orbElement->getAttributes(); << 954 XMLSize_t attributeCount = attributes->getLe << 955 << 956 for(XMLSize_t attribute_index = 0; attribute << 957 ++attribute_index) << 958 { << 959 xercesc::DOMNode* attribute_node = attribu << 960 << 961 if(attribute_node->getNodeType() != xerces << 962 { << 963 continue; << 964 } << 965 << 966 const xercesc::DOMAttr* const attribute = << 967 dynamic_cast<xercesc::DOMAttr*>(attribut << 968 if(attribute == nullptr) << 969 { << 970 G4Exception("G4GDMLReadSolids::OrbRead() << 971 "No attribute found!"); << 972 return; << 973 } << 974 const G4String attName = Transcode(attrib << 975 const G4String attValue = Transcode(attrib << 976 << 977 if(attName == "name") << 978 { << 979 name = GenerateName(attValue); << 980 } << 981 else if(attName == "lunit") << 982 { << 983 lunit = G4UnitDefinition::GetValueOf(att << 984 if(G4UnitDefinition::GetCategory(attValu << 985 { << 986 G4Exception("G4GDMLReadSolids::OrbRead << 987 FatalException, "Invalid u << 988 } << 989 } << 990 else if(attName == "r") << 991 { << 992 r = eval.Evaluate(attValue); << 993 } << 994 } << 995 << 996 r *= lunit; << 997 << 998 new G4Orb(name, r); << 999 } << 1000 << 1001 // ------------------------------------------ << 1002 void G4GDMLReadSolids::ParaRead(const xercesc << 1003 { << 1004 G4String name; << 1005 G4double lunit = 1.0; << 1006 G4double aunit = 1.0; << 1007 G4double x = 0.0; << 1008 G4double y = 0.0; << 1009 G4double z = 0.0; << 1010 G4double alpha = 0.0; << 1011 G4double theta = 0.0; << 1012 G4double phi = 0.0; << 1013 << 1014 const xercesc::DOMNamedNodeMap* const attri << 1015 paraElement->getAttributes(); << 1016 XMLSize_t attributeCount = attributes->getL << 1017 << 1018 for(XMLSize_t attribute_index = 0; attribut << 1019 ++attribute_index) << 1020 { << 1021 xercesc::DOMNode* attribute_node = attrib << 1022 << 1023 if(attribute_node->getNodeType() != xerce << 1024 { << 1025 continue; << 1026 } << 1027 << 1028 const xercesc::DOMAttr* const attribute = << 1029 dynamic_cast<xercesc::DOMAttr*>(attribu << 1030 if(attribute == nullptr) << 1031 { << 1032 G4Exception("G4GDMLReadSolids::ParaRead << 1033 "No attribute found!"); << 1034 return; << 1035 } << 1036 const G4String attName = Transcode(attri << 1037 const G4String attValue = Transcode(attri << 1038 << 1039 if(attName == "name") << 1040 { << 1041 name = GenerateName(attValue); << 1042 } << 1043 else if(attName == "lunit") << 1044 { << 1045 lunit = G4UnitDefinition::GetValueOf(at << 1046 if(G4UnitDefinition::GetCategory(attVal << 1047 { << 1048 G4Exception("G4GDMLReadSolids::ParaRe << 1049 FatalException, "Invalid << 1050 } << 1051 } << 1052 else if(attName == "aunit") << 1053 { << 1054 aunit = G4UnitDefinition::GetValueOf(at << 1055 if(G4UnitDefinition::GetCategory(attVal << 1056 { << 1057 G4Exception("G4GDMLReadSolids::ParaRe << 1058 FatalException, "Invalid << 1059 } << 1060 } << 1061 else if(attName == "x") << 1062 { << 1063 x = eval.Evaluate(attValue); << 1064 } << 1065 else if(attName == "y") << 1066 { << 1067 y = eval.Evaluate(attValue); << 1068 } << 1069 else if(attName == "z") << 1070 { << 1071 z = eval.Evaluate(attValue); << 1072 } << 1073 else if(attName == "alpha") << 1074 { << 1075 alpha = eval.Evaluate(attValue); << 1076 } << 1077 else if(attName == "theta") << 1078 { << 1079 theta = eval.Evaluate(attValue); << 1080 } << 1081 else if(attName == "phi") << 1082 { << 1083 phi = eval.Evaluate(attValue); << 1084 } << 1085 } << 1086 << 1087 x *= 0.5 * lunit; << 1088 y *= 0.5 * lunit; << 1089 z *= 0.5 * lunit; << 1090 alpha *= aunit; << 1091 theta *= aunit; << 1092 phi *= aunit; << 1093 << 1094 new G4Para(name, x, y, z, alpha, theta, phi << 1095 } << 1096 << 1097 // ------------------------------------------ << 1098 void G4GDMLReadSolids::ParaboloidRead( << 1099 const xercesc::DOMElement* const paraElemen << 1100 { << 1101 G4String name; << 1102 G4double lunit = 1.0; << 1103 G4double rlo = 0.0; << 1104 G4double rhi = 0.0; << 1105 G4double dz = 0.0; << 1106 << 1107 const xercesc::DOMNamedNodeMap* const attri << 1108 paraElement->getAttributes(); << 1109 XMLSize_t attributeCount = attributes->getL << 1110 << 1111 for(XMLSize_t attribute_index = 0; attribut << 1112 ++attribute_index) << 1113 { << 1114 xercesc::DOMNode* attribute_node = attrib << 1115 << 1116 if(attribute_node->getNodeType() != xerce << 1117 { << 1118 continue; << 1119 } << 1120 << 1121 const xercesc::DOMAttr* const attribute = << 1122 dynamic_cast<xercesc::DOMAttr*>(attribu << 1123 if(attribute == nullptr) << 1124 { << 1125 G4Exception("G4GDMLReadSolids::Parabolo << 1126 FatalException, "No attribu << 1127 return; << 1128 } << 1129 const G4String attName = Transcode(attri << 1130 const G4String attValue = Transcode(attri << 1131 << 1132 if(attName == "name") << 1133 { << 1134 name = GenerateName(attValue); << 1135 } << 1136 else if(attName == "lunit") << 1137 { << 1138 lunit = G4UnitDefinition::GetValueOf(at << 1139 if(G4UnitDefinition::GetCategory(attVal << 1140 { << 1141 G4Exception("G4GDMLReadSolids::Parabo << 1142 FatalException, "Invalid << 1143 } << 1144 } << 1145 else if(attName == "rlo") << 1146 { << 1147 rlo = eval.Evaluate(attValue); << 1148 } << 1149 else if(attName == "rhi") << 1150 { << 1151 rhi = eval.Evaluate(attValue); << 1152 } << 1153 else if(attName == "dz") << 1154 { << 1155 dz = eval.Evaluate(attValue); << 1156 } << 1157 } << 1158 << 1159 rlo *= 1. * lunit; << 1160 rhi *= 1. * lunit; << 1161 dz *= 1. * lunit; << 1162 458 1163 new G4Paraboloid(name, dz, rlo, rhi); << 459 const xercesc::DOMNamedNodeMap* const attributes 1164 } << 460 = xtruElement->getAttributes(); >> 461 XMLSize_t attributeCount = attributes->getLength(); 1165 462 1166 // ------------------------------------------ << 463 for (XMLSize_t attribute_index=0; 1167 void G4GDMLReadSolids::PolyconeRead( << 464 attribute_index<attributeCount; attribute_index++) 1168 const xercesc::DOMElement* const polyconeEl << 465 { 1169 { << 466 xercesc::DOMNode* attribute_node = attributes->item(attribute_index); 1170 G4String name; << 1171 G4double lunit = 1.0; << 1172 G4double aunit = 1.0; << 1173 G4double startphi = 0.0; << 1174 G4double deltaphi = 0.0; << 1175 << 1176 const xercesc::DOMNamedNodeMap* const attri << 1177 polyconeElement->getAttributes(); << 1178 XMLSize_t attributeCount = attributes->getL << 1179 << 1180 for(XMLSize_t attribute_index = 0; attribut << 1181 ++attribute_index) << 1182 { << 1183 xercesc::DOMNode* attribute_node = attrib << 1184 << 1185 if(attribute_node->getNodeType() != xerce << 1186 { << 1187 continue; << 1188 } << 1189 << 1190 const xercesc::DOMAttr* const attribute = << 1191 dynamic_cast<xercesc::DOMAttr*>(attribu << 1192 if(attribute == nullptr) << 1193 { << 1194 G4Exception("G4GDMLReadSolids::Polycone << 1195 FatalException, "No attribu << 1196 return; << 1197 } << 1198 const G4String attName = Transcode(attri << 1199 const G4String attValue = Transcode(attri << 1200 << 1201 if(attName == "name") << 1202 { << 1203 name = GenerateName(attValue); << 1204 } << 1205 else if(attName == "lunit") << 1206 { << 1207 lunit = G4UnitDefinition::GetValueOf(at << 1208 if(G4UnitDefinition::GetCategory(attVal << 1209 { << 1210 G4Exception("G4GDMLReadSolids::Polyco << 1211 FatalException, "Invalid << 1212 } << 1213 } << 1214 else if(attName == "aunit") << 1215 { << 1216 aunit = G4UnitDefinition::GetValueOf(at << 1217 if(G4UnitDefinition::GetCategory(attVal << 1218 { << 1219 G4Exception("G4GDMLReadSolids::Polyco << 1220 FatalException, "Invalid << 1221 } << 1222 } << 1223 else if(attName == "startphi") << 1224 { << 1225 startphi = eval.Evaluate(attValue); << 1226 } << 1227 else if(attName == "deltaphi") << 1228 { << 1229 deltaphi = eval.Evaluate(attValue); << 1230 } << 1231 } << 1232 << 1233 startphi *= aunit; << 1234 deltaphi *= aunit; << 1235 << 1236 std::vector<zplaneType> zplaneList; << 1237 << 1238 for(xercesc::DOMNode* iter = polyconeElemen << 1239 iter = iter->getNextS << 1240 { << 1241 if(iter->getNodeType() != xercesc::DOMNod << 1242 { << 1243 continue; << 1244 } << 1245 << 1246 const xercesc::DOMElement* const child = << 1247 dynamic_cast<xercesc::DOMElement*>(iter << 1248 if(child == nullptr) << 1249 { << 1250 G4Exception("G4GDMLReadSolids::Polycone << 1251 FatalException, "No child f << 1252 return; << 1253 } << 1254 const G4String tag = Transcode(child->get << 1255 << 1256 if(tag == "zplane") << 1257 { << 1258 zplaneList.push_back(ZplaneRead(child)) << 1259 } << 1260 } << 1261 << 1262 std::size_t numZPlanes = zplaneList.size(); << 1263 << 1264 G4double* rmin_array = new G4double[numZPla << 1265 G4double* rmax_array = new G4double[numZPla << 1266 G4double* z_array = new G4double[numZPla << 1267 << 1268 for(std::size_t i = 0; i < numZPlanes; ++i) << 1269 { << 1270 rmin_array[i] = zplaneList[i].rmin * luni << 1271 rmax_array[i] = zplaneList[i].rmax * luni << 1272 z_array[i] = zplaneList[i].z * lunit; << 1273 } << 1274 << 1275 new G4Polycone(name, startphi, deltaphi, (G << 1276 rmin_array, rmax_array); << 1277 << 1278 delete[] rmin_array; << 1279 delete[] rmax_array; << 1280 delete[] z_array; << 1281 } << 1282 467 1283 // ------------------------------------------ << 468 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE) 1284 void G4GDMLReadSolids::GenericPolyconeRead( << 469 { continue; } 1285 const xercesc::DOMElement* const polyconeEl << 1286 { << 1287 G4String name; << 1288 G4double lunit = 1.0; << 1289 G4double aunit = 1.0; << 1290 G4double startphi = 0.0; << 1291 G4double deltaphi = 0.0; << 1292 << 1293 const xercesc::DOMNamedNodeMap* const attri << 1294 polyconeElement->getAttributes(); << 1295 XMLSize_t attributeCount = attributes->getL << 1296 << 1297 for(XMLSize_t attribute_index = 0; attribut << 1298 ++attribute_index) << 1299 { << 1300 xercesc::DOMNode* attribute_node = attrib << 1301 << 1302 if(attribute_node->getNodeType() != xerce << 1303 { << 1304 continue; << 1305 } << 1306 << 1307 const xercesc::DOMAttr* const attribute = << 1308 dynamic_cast<xercesc::DOMAttr*>(attribu << 1309 if(attribute == nullptr) << 1310 { << 1311 G4Exception("G4GDMLReadSolids::GenericP << 1312 FatalException, "No attribu << 1313 return; << 1314 } << 1315 const G4String attName = Transcode(attri << 1316 const G4String attValue = Transcode(attri << 1317 << 1318 if(attName == "name") << 1319 { << 1320 name = GenerateName(attValue); << 1321 } << 1322 else if(attName == "lunit") << 1323 { << 1324 lunit = G4UnitDefinition::GetValueOf(at << 1325 if(G4UnitDefinition::GetCategory(attVal << 1326 { << 1327 G4Exception("G4GDMLReadSolids::Generi << 1328 FatalException, "Invalid << 1329 } << 1330 } << 1331 else if(attName == "aunit") << 1332 { << 1333 aunit = G4UnitDefinition::GetValueOf(at << 1334 if(G4UnitDefinition::GetCategory(attVal << 1335 { << 1336 G4Exception("G4GDMLReadSolids::Generi << 1337 FatalException, "Invalid << 1338 } << 1339 } << 1340 else if(attName == "startphi") << 1341 { << 1342 startphi = eval.Evaluate(attValue); << 1343 } << 1344 else if(attName == "deltaphi") << 1345 { << 1346 deltaphi = eval.Evaluate(attValue); << 1347 } << 1348 } << 1349 << 1350 startphi *= aunit; << 1351 deltaphi *= aunit; << 1352 << 1353 std::vector<rzPointType> rzPointList; << 1354 << 1355 for(xercesc::DOMNode* iter = polyconeElemen << 1356 iter != nullptr; iter << 1357 { << 1358 if(iter->getNodeType() != xercesc::DOMNod << 1359 { << 1360 continue; << 1361 } << 1362 << 1363 const xercesc::DOMElement* const child = << 1364 dynamic_cast<xercesc::DOMElement*>(iter << 1365 if(child == nullptr) << 1366 { << 1367 G4Exception("G4GDMLReadSolids::GenericP << 1368 FatalException, "No child f << 1369 return; << 1370 } << 1371 const G4String tag = Transcode(child->get << 1372 << 1373 if(tag == "rzpoint") << 1374 { << 1375 rzPointList.push_back(RZPointRead(child << 1376 } << 1377 } << 1378 << 1379 std::size_t numRZPoints = rzPointList.size( << 1380 << 1381 G4double* r_array = new G4double[numRZPoint << 1382 G4double* z_array = new G4double[numRZPoint << 1383 << 1384 for(std::size_t i = 0; i < numRZPoints; ++i << 1385 { << 1386 r_array[i] = rzPointList[i].r * lunit; << 1387 z_array[i] = rzPointList[i].z * lunit; << 1388 } << 1389 new G4GenericPolycone(name, startphi, delta << 1390 r_array, z_array); << 1391 delete[] r_array; << 1392 delete[] z_array; << 1393 } << 1394 470 1395 // ------------------------------------------ << 471 const xercesc::DOMAttr* const attribute 1396 void G4GDMLReadSolids::PolyhedraRead( << 472 = dynamic_cast<xercesc::DOMAttr*>(attribute_node); 1397 const xercesc::DOMElement* const polyhedraE << 473 if (!attribute) 1398 { << 474 { 1399 G4String name; << 475 G4Exception("G4GDMLReadSolids::XtruRead()", 1400 G4double lunit = 1.0; << 476 "InvalidRead", FatalException, "No attribute found!"); 1401 G4double aunit = 1.0; << 477 return; 1402 G4double startphi = 0.0; << 478 } 1403 G4double deltaphi = 0.0; << 479 const G4String attName = Transcode(attribute->getName()); 1404 G4int numsides = 0; << 480 const G4String attValue = Transcode(attribute->getValue()); 1405 << 1406 const xercesc::DOMNamedNodeMap* const attri << 1407 polyhedraElement->getAttributes(); << 1408 XMLSize_t attributeCount = attributes->getL << 1409 << 1410 for(XMLSize_t attribute_index = 0; attribut << 1411 ++attribute_index) << 1412 { << 1413 xercesc::DOMNode* attribute_node = attrib << 1414 << 1415 if(attribute_node->getNodeType() != xerce << 1416 { << 1417 continue; << 1418 } << 1419 << 1420 const xercesc::DOMAttr* const attribute = << 1421 dynamic_cast<xercesc::DOMAttr*>(attribu << 1422 if(attribute == nullptr) << 1423 { << 1424 G4Exception("G4GDMLReadSolids::Polyhedr << 1425 FatalException, "No attribu << 1426 return; << 1427 } << 1428 const G4String attName = Transcode(attri << 1429 const G4String attValue = Transcode(attri << 1430 << 1431 if(attName == "name") << 1432 { << 1433 name = GenerateName(attValue); << 1434 } << 1435 else if(attName == "lunit") << 1436 { << 1437 lunit = G4UnitDefinition::GetValueOf(at << 1438 if(G4UnitDefinition::GetCategory(attVal << 1439 { << 1440 G4Exception("G4GDMLReadSolids::Polyhe << 1441 FatalException, "Invalid << 1442 } << 1443 } << 1444 else if(attName == "aunit") << 1445 { << 1446 aunit = G4UnitDefinition::GetValueOf(at << 1447 if(G4UnitDefinition::GetCategory(attVal << 1448 { << 1449 G4Exception("G4GDMLReadSolids::Polyhe << 1450 FatalException, "Invalid << 1451 } << 1452 } << 1453 else if(attName == "startphi") << 1454 { << 1455 startphi = eval.Evaluate(attValue); << 1456 } << 1457 else if(attName == "deltaphi") << 1458 { << 1459 deltaphi = eval.Evaluate(attValue); << 1460 } << 1461 else if(attName == "numsides") << 1462 { << 1463 numsides = eval.EvaluateInteger(attValu << 1464 } << 1465 } << 1466 << 1467 startphi *= aunit; << 1468 deltaphi *= aunit; << 1469 << 1470 std::vector<zplaneType> zplaneList; << 1471 << 1472 for(xercesc::DOMNode* iter = polyhedraEleme << 1473 iter != nullptr; iter << 1474 { << 1475 if(iter->getNodeType() != xercesc::DOMNod << 1476 { << 1477 continue; << 1478 } << 1479 << 1480 const xercesc::DOMElement* const child = << 1481 dynamic_cast<xercesc::DOMElement*>(iter << 1482 if(child == nullptr) << 1483 { << 1484 G4Exception("G4GDMLReadSolids::Polyhedr << 1485 FatalException, "No child f << 1486 return; << 1487 } << 1488 const G4String tag = Transcode(child->get << 1489 << 1490 if(tag == "zplane") << 1491 { << 1492 zplaneList.push_back(ZplaneRead(child)) << 1493 } << 1494 } << 1495 << 1496 std::size_t numZPlanes = zplaneList.size(); << 1497 << 1498 G4double* rmin_array = new G4double[numZPla << 1499 G4double* rmax_array = new G4double[numZPla << 1500 G4double* z_array = new G4double[numZPla << 1501 << 1502 for(std::size_t i = 0; i < numZPlanes; ++i) << 1503 { << 1504 rmin_array[i] = zplaneList[i].rmin * luni << 1505 rmax_array[i] = zplaneList[i].rmax * luni << 1506 z_array[i] = zplaneList[i].z * lunit; << 1507 } << 1508 << 1509 new G4Polyhedra(name, startphi, deltaphi, n << 1510 z_array, rmin_array, rmax_a << 1511 << 1512 delete[] rmin_array; << 1513 delete[] rmax_array; << 1514 delete[] z_array; << 1515 } << 1516 481 1517 // ------------------------------------------ << 482 if (attName=="name") { name = GenerateName(attValue); } else 1518 void G4GDMLReadSolids::GenericPolyhedraRead( << 483 if (attName=="lunit") { lunit = G4UnitDefinition::GetValueOf(attValue); 1519 const xercesc::DOMElement* const polyhedraE << 484 if (G4UnitDefinition::GetCategory(attValue)!="Length") { 1520 { << 485 G4Exception("G4GDMLReadSolids::XtruRead()", "InvalidRead", 1521 G4String name; << 486 FatalException, "Invalid unit for length!"); } 1522 G4double lunit = 1.0; << 487 } 1523 G4double aunit = 1.0; << 488 } 1524 G4double startphi = 0.0; << 1525 G4double deltaphi = 0.0; << 1526 G4int numsides = 0; << 1527 << 1528 const xercesc::DOMNamedNodeMap* const attri << 1529 polyhedraElement->getAttributes(); << 1530 XMLSize_t attributeCount = attributes->getL << 1531 << 1532 for(XMLSize_t attribute_index = 0; attribut << 1533 ++attribute_index) << 1534 { << 1535 xercesc::DOMNode* attribute_node = attrib << 1536 << 1537 if(attribute_node->getNodeType() != xerce << 1538 { << 1539 continue; << 1540 } << 1541 << 1542 const xercesc::DOMAttr* const attribute = << 1543 dynamic_cast<xercesc::DOMAttr*>(attribu << 1544 if(attribute == nullptr) << 1545 { << 1546 G4Exception("G4GDMLReadSolids::GenericP << 1547 FatalException, "No attribu << 1548 return; << 1549 } << 1550 const G4String attName = Transcode(attri << 1551 const G4String attValue = Transcode(attri << 1552 << 1553 if(attName == "name") << 1554 { << 1555 name = GenerateName(attValue); << 1556 } << 1557 else if(attName == "lunit") << 1558 { << 1559 lunit = G4UnitDefinition::GetValueOf(at << 1560 if(G4UnitDefinition::GetCategory(attVal << 1561 { << 1562 G4Exception("G4GDMLReadSolids::Generi << 1563 FatalException, "Invalid << 1564 } << 1565 } << 1566 else if(attName == "aunit") << 1567 { << 1568 aunit = G4UnitDefinition::GetValueOf(at << 1569 if(G4UnitDefinition::GetCategory(attVal << 1570 { << 1571 G4Exception("G4GDMLReadSolids::Generi << 1572 FatalException, "Invalid << 1573 } << 1574 } << 1575 else if(attName == "startphi") << 1576 { << 1577 startphi = eval.Evaluate(attValue); << 1578 } << 1579 else if(attName == "deltaphi") << 1580 { << 1581 deltaphi = eval.Evaluate(attValue); << 1582 } << 1583 else if(attName == "numsides") << 1584 { << 1585 numsides = eval.EvaluateInteger(attValu << 1586 } << 1587 } << 1588 << 1589 startphi *= aunit; << 1590 deltaphi *= aunit; << 1591 << 1592 std::vector<rzPointType> rzpointList; << 1593 << 1594 for(xercesc::DOMNode* iter = polyhedraEleme << 1595 iter != nullptr; iter << 1596 { << 1597 if(iter->getNodeType() != xercesc::DOMNod << 1598 { << 1599 continue; << 1600 } << 1601 << 1602 const xercesc::DOMElement* const child = << 1603 dynamic_cast<xercesc::DOMElement*>(iter << 1604 if(child == nullptr) << 1605 { << 1606 G4Exception("G4GDMLReadSolids::GenericP << 1607 FatalException, "No child f << 1608 return; << 1609 } << 1610 const G4String tag = Transcode(child->get << 1611 << 1612 if(tag == "rzpoint") << 1613 { << 1614 rzpointList.push_back(RZPointRead(child << 1615 } << 1616 } << 1617 << 1618 std::size_t numRZPoints = rzpointList.size( << 1619 << 1620 G4double* r_array = new G4double[numRZPoint << 1621 G4double* z_array = new G4double[numRZPoint << 1622 << 1623 for(std::size_t i = 0; i < numRZPoints; ++i << 1624 { << 1625 r_array[i] = rzpointList[i].r * lunit; << 1626 z_array[i] = rzpointList[i].z * lunit; << 1627 } << 1628 489 1629 new G4Polyhedra(name, startphi, deltaphi, n << 490 std::vector<G4TwoVector> twoDimVertexList; 1630 r_array, z_array); << 491 std::vector<G4ExtrudedSolid::ZSection> sectionList; 1631 492 1632 delete[] r_array; << 493 for (xercesc::DOMNode* iter = xtruElement->getFirstChild(); 1633 delete[] z_array; << 494 iter != 0; iter = iter->getNextSibling()) 1634 } << 495 { >> 496 if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE) { continue; } 1635 497 1636 // ------------------------------------------ << 498 const xercesc::DOMElement* const child 1637 G4QuadrangularFacet* G4GDMLReadSolids::Quadra << 499 = dynamic_cast<xercesc::DOMElement*>(iter); 1638 const xercesc::DOMElement* const quadrangul << 500 if (!child) 1639 { << 1640 G4ThreeVector vertex1; << 1641 G4ThreeVector vertex2; << 1642 G4ThreeVector vertex3; << 1643 G4ThreeVector vertex4; << 1644 G4FacetVertexType type = ABSOLUTE; << 1645 G4double lunit = 1.0; << 1646 << 1647 const xercesc::DOMNamedNodeMap* const attri << 1648 quadrangularElement->getAttributes(); << 1649 XMLSize_t attributeCount = attributes->getL << 1650 << 1651 for(XMLSize_t attribute_index = 0; attribut << 1652 ++attribute_index) << 1653 { << 1654 xercesc::DOMNode* attribute_node = attrib << 1655 << 1656 if(attribute_node->getNodeType() != xerce << 1657 { << 1658 continue; << 1659 } << 1660 << 1661 const xercesc::DOMAttr* const attribute = << 1662 dynamic_cast<xercesc::DOMAttr*>(attribu << 1663 if(attribute == nullptr) << 1664 { << 1665 G4Exception("G4GDMLReadSolids::Quadrang << 1666 FatalException, "No attribu << 1667 return nullptr; << 1668 } << 1669 const G4String attName = Transcode(attri << 1670 const G4String attValue = Transcode(attri << 1671 << 1672 if(attName == "vertex1") << 1673 { << 1674 vertex1 = GetPosition(GenerateName(attV << 1675 } << 1676 else if(attName == "vertex2") << 1677 { << 1678 vertex2 = GetPosition(GenerateName(attV << 1679 } << 1680 else if(attName == "vertex3") << 1681 { << 1682 vertex3 = GetPosition(GenerateName(attV << 1683 } << 1684 else if(attName == "vertex4") << 1685 { << 1686 vertex4 = GetPosition(GenerateName(attV << 1687 } << 1688 else if(attName == "lunit") << 1689 { << 1690 lunit = G4UnitDefinition::GetValueOf(at << 1691 if(G4UnitDefinition::GetCategory(attVal << 1692 { << 1693 G4Exception("G4GDMLReadSolids::Quadra << 1694 FatalException, "Invalid << 1695 } << 1696 } << 1697 else if(attName == "type") << 1698 { << 1699 if(attValue == "RELATIVE") << 1700 { 501 { 1701 type = RELATIVE; << 502 G4Exception("G4GDMLReadSolids::XtruRead()", >> 503 "InvalidRead", FatalException, "No child found!"); >> 504 return; 1702 } 505 } 1703 } << 506 const G4String tag = Transcode(child->getTagName()); 1704 } << 1705 507 1706 return new G4QuadrangularFacet(vertex1 * lu << 508 if (tag=="twoDimVertex") 1707 vertex3 * lu << 509 { twoDimVertexList.push_back(TwoDimVertexRead(child,lunit)); } else 1708 } << 510 if (tag=="section") >> 511 { sectionList.push_back(SectionRead(child,lunit)); } >> 512 } 1709 513 1710 // ------------------------------------------ << 514 new G4ExtrudedSolid(name,twoDimVertexList,sectionList); 1711 void G4GDMLReadSolids::ReflectedSolidRead( << 1712 const xercesc::DOMElement* const reflectedS << 1713 { << 1714 G4String name; << 1715 G4double lunit = 1.0; << 1716 G4double aunit = 1.0; << 1717 G4String solid; << 1718 G4ThreeVector scale(1.0, 1.0, 1.0); << 1719 G4ThreeVector rotation; << 1720 G4ThreeVector position; << 1721 << 1722 const xercesc::DOMNamedNodeMap* const attri << 1723 reflectedSolidElement->getAttributes(); << 1724 XMLSize_t attributeCount = attributes->getL << 1725 << 1726 for(XMLSize_t attribute_index = 0; attribut << 1727 ++attribute_index) << 1728 { << 1729 xercesc::DOMNode* attribute_node = attrib << 1730 << 1731 if(attribute_node->getNodeType() != xerce << 1732 { << 1733 continue; << 1734 } << 1735 << 1736 const xercesc::DOMAttr* const attribute = << 1737 dynamic_cast<xercesc::DOMAttr*>(attribu << 1738 if(attribute == nullptr) << 1739 { << 1740 G4Exception("G4GDMLReadSolids::Reflecte << 1741 FatalException, "No attribu << 1742 return; << 1743 } << 1744 const G4String attName = Transcode(attri << 1745 const G4String attValue = Transcode(attri << 1746 << 1747 if(attName == "name") << 1748 { << 1749 name = GenerateName(attValue); << 1750 } << 1751 else if(attName == "lunit") << 1752 { << 1753 lunit = G4UnitDefinition::GetValueOf(at << 1754 if(G4UnitDefinition::GetCategory(attVal << 1755 { << 1756 G4Exception("G4GDMLReadSolids::Reflec << 1757 FatalException, "Invalid << 1758 } << 1759 } << 1760 else if(attName == "aunit") << 1761 { << 1762 aunit = G4UnitDefinition::GetValueOf(at << 1763 if(G4UnitDefinition::GetCategory(attVal << 1764 { << 1765 G4Exception("G4GDMLReadSolids::Reflec << 1766 FatalException, "Invalid << 1767 } << 1768 } << 1769 else if(attName == "solid") << 1770 { << 1771 solid = GenerateName(attValue); << 1772 } << 1773 else if(attName == "sx") << 1774 { << 1775 scale.setX(eval.Evaluate(attValue)); << 1776 } << 1777 else if(attName == "sy") << 1778 { << 1779 scale.setY(eval.Evaluate(attValue)); << 1780 } << 1781 else if(attName == "sz") << 1782 { << 1783 scale.setZ(eval.Evaluate(attValue)); << 1784 } << 1785 else if(attName == "rx") << 1786 { << 1787 rotation.setX(eval.Evaluate(attValue)); << 1788 } << 1789 else if(attName == "ry") << 1790 { << 1791 rotation.setY(eval.Evaluate(attValue)); << 1792 } << 1793 else if(attName == "rz") << 1794 { << 1795 rotation.setZ(eval.Evaluate(attValue)); << 1796 } << 1797 else if(attName == "dx") << 1798 { << 1799 position.setX(eval.Evaluate(attValue)); << 1800 } << 1801 else if(attName == "dy") << 1802 { << 1803 position.setY(eval.Evaluate(attValue)); << 1804 } << 1805 else if(attName == "dz") << 1806 { << 1807 position.setZ(eval.Evaluate(attValue)); << 1808 } << 1809 } << 1810 << 1811 rotation *= aunit; << 1812 position *= lunit; << 1813 << 1814 G4Transform3D transform(GetRotationMatrix(r << 1815 transform = transform * G4Scale3D(scale.x() << 1816 << 1817 new G4ReflectedSolid(name, GetSolid(solid), << 1818 } 515 } 1819 516 1820 // ------------------------------------------ << 517 void G4GDMLReadSolids::HypeRead(const xercesc::DOMElement* const hypeElement) 1821 void G4GDMLReadSolids::ScaledSolidRead( << 1822 const xercesc::DOMElement* const scaledSoli << 1823 { 518 { 1824 G4String name; << 519 G4String name; 1825 G4VSolid* solid = nullptr; << 520 G4double lunit = 1.0; 1826 G4ThreeVector scale(1.0, 1.0, 1.0); << 521 G4double aunit = 1.0; 1827 << 522 G4double rmin = 0.0; 1828 const xercesc::DOMNamedNodeMap* const attri << 523 G4double rmax = 0.0; 1829 scaledSolidElement->getAttributes(); << 524 G4double inst = 0.0; 1830 XMLSize_t attributeCount = attributes->getL << 525 G4double outst = 0.0; 1831 << 526 G4double z = 0.0; 1832 for(XMLSize_t attribute_index = 0; attribut << 527 1833 ++attribute_index) << 528 const xercesc::DOMNamedNodeMap* const attributes 1834 { << 529 = hypeElement->getAttributes(); 1835 xercesc::DOMNode* attribute_node = attrib << 530 XMLSize_t attributeCount = attributes->getLength(); 1836 << 531 1837 if(attribute_node->getNodeType() != xerce << 532 for (XMLSize_t attribute_index=0; 1838 { << 533 attribute_index<attributeCount; attribute_index++) 1839 continue; << 534 { 1840 } << 535 xercesc::DOMNode* attribute_node = attributes->item(attribute_index); 1841 << 536 1842 const xercesc::DOMAttr* const attribute = << 537 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE) 1843 dynamic_cast<xercesc::DOMAttr*>(attribu << 538 { continue; } 1844 if(attribute == nullptr) << 539 1845 { << 540 const xercesc::DOMAttr* const attribute 1846 G4Exception("G4GDMLReadSolids::ScaledSo << 541 = dynamic_cast<xercesc::DOMAttr*>(attribute_node); 1847 FatalException, "No attribu << 542 if (!attribute) 1848 return; << 543 { 1849 } << 544 G4Exception("G4GDMLReadSolids::HypeRead()", 1850 const G4String attName = Transcode(attri << 545 "InvalidRead", FatalException, "No attribute found!"); 1851 const G4String attValue = Transcode(attri << 546 return; 1852 << 547 } 1853 if(attName == "name") << 548 const G4String attName = Transcode(attribute->getName()); 1854 { << 549 const G4String attValue = Transcode(attribute->getValue()); 1855 name = GenerateName(attValue); << 550 1856 } << 551 if (attName=="name") { name = GenerateName(attValue); } else 1857 } << 552 if (attName=="lunit") { lunit = G4UnitDefinition::GetValueOf(attValue); 1858 << 553 if (G4UnitDefinition::GetCategory(attValue)!="Length") { 1859 for(xercesc::DOMNode* iter = scaledSolidEle << 554 G4Exception("G4GDMLReadSolids::HypeRead()", "InvalidRead", 1860 iter != nullptr; iter << 555 FatalException, "Invalid unit for length!"); } 1861 { << 556 } else 1862 if(iter->getNodeType() != xercesc::DOMNod << 557 if (attName=="aunit") { aunit = G4UnitDefinition::GetValueOf(attValue); 1863 { << 558 if (G4UnitDefinition::GetCategory(attValue)!="Angle") { 1864 continue; << 559 G4Exception("G4GDMLReadSolids::HypeRead()", "InvalidRead", 1865 } << 560 FatalException, "Invalid unit for angle!"); } 1866 << 561 } else 1867 const xercesc::DOMElement* const child = << 562 if (attName=="rmin") { rmin = eval.Evaluate(attValue); } else 1868 dynamic_cast<xercesc::DOMElement*>(iter << 563 if (attName=="rmax") { rmax = eval.Evaluate(attValue); } else 1869 if(child == nullptr) << 564 if (attName=="inst") { inst = eval.Evaluate(attValue); } else 1870 { << 565 if (attName=="outst") { outst = eval.Evaluate(attValue); } else 1871 G4Exception("G4GDMLReadSolids::ScaledSo << 566 if (attName=="z") { z = eval.Evaluate(attValue); } 1872 FatalException, "No child f << 567 } 1873 return; << 568 1874 } << 569 rmin *= lunit; 1875 const G4String tag = Transcode(child->get << 570 rmax *= lunit; 1876 << 571 inst *= aunit; 1877 if(tag == "solidref") << 572 outst *= aunit; 1878 { << 573 z *= 0.5*lunit; 1879 solid = GetSolid(GenerateName(RefRead(c << 574 1880 } << 575 new G4Hype(name,rmin,rmax,inst,outst,z); 1881 else if(tag == "scale") << 576 } 1882 { << 577 1883 VectorRead(child, scale); << 578 void G4GDMLReadSolids:: 1884 } << 579 MultiUnionNodeRead(const xercesc::DOMElement* const unionNodeElement, 1885 else if(tag == "scaleref") << 580 G4MultiUnion* const multiUnionSolid) 1886 { << 581 { 1887 scale = GetScale(GenerateName(RefRead(c << 582 G4String name; 1888 } << 583 G4String solid; 1889 else << 584 G4ThreeVector position(0.0,0.0,0.0); 1890 { << 585 G4ThreeVector rotation(0.0,0.0,0.0); 1891 G4String error_msg = "Unknown tag in sc << 586 1892 G4Exception("G4GDMLReadSolids::ScaledSo << 587 const xercesc::DOMNamedNodeMap* const attributes 1893 FatalException, error_msg); << 588 = unionNodeElement->getAttributes(); 1894 return; << 589 XMLSize_t attributeCount = attributes->getLength(); 1895 } << 590 1896 } << 591 for (XMLSize_t attribute_index=0; 1897 << 592 attribute_index<attributeCount; attribute_index++) 1898 G4Scale3D transform = G4Scale3D(scale.x(), << 593 { 1899 << 594 xercesc::DOMNode* attribute_node = attributes->item(attribute_index); 1900 new G4ScaledSolid(name, solid, transform); << 595 >> 596 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE) >> 597 { continue; } >> 598 >> 599 const xercesc::DOMAttr* const attribute >> 600 = dynamic_cast<xercesc::DOMAttr*>(attribute_node); >> 601 if (!attribute) >> 602 { >> 603 G4Exception("G4GDMLReadSolids::MultiUnionNodeRead()", >> 604 "InvalidRead", FatalException, "No attribute found!"); >> 605 return; >> 606 } >> 607 const G4String attName = Transcode(attribute->getName()); >> 608 const G4String attValue = Transcode(attribute->getValue()); >> 609 >> 610 if (attName=="name") { name = GenerateName(attValue); } >> 611 } >> 612 >> 613 for (xercesc::DOMNode* iter = unionNodeElement->getFirstChild(); >> 614 iter != 0;iter = iter->getNextSibling()) >> 615 { >> 616 if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE) { continue; } >> 617 >> 618 const xercesc::DOMElement* const child >> 619 = dynamic_cast<xercesc::DOMElement*>(iter); >> 620 if (!child) >> 621 { >> 622 G4Exception("G4GDMLReadSolids::MultiUnionNodeRead()", >> 623 "InvalidRead", FatalException, "No child found!"); >> 624 return; >> 625 } >> 626 const G4String tag = Transcode(child->getTagName()); >> 627 >> 628 if (tag=="position") { VectorRead(child,position); } else >> 629 if (tag=="rotation") { VectorRead(child,rotation); } else >> 630 if (tag=="positionref") >> 631 { position = GetPosition(GenerateName(RefRead(child))); } else >> 632 if (tag=="rotationref") >> 633 { rotation = GetRotation(GenerateName(RefRead(child))); } else >> 634 if (tag=="solid") { solid = RefRead(child); } >> 635 else >> 636 { >> 637 G4String error_msg = "Unknown tag in MultiUnion structure: " + tag; >> 638 G4Exception("G4GDMLReadSolids::MultiUnionNodeRead()", "ReadError", >> 639 FatalException, error_msg); >> 640 } >> 641 } >> 642 G4VSolid* solidNode = GetSolid(GenerateName(solid)); >> 643 G4Transform3D transform(GetRotationMatrix(rotation),position); >> 644 multiUnionSolid->AddNode(*solidNode, transform); >> 645 } >> 646 >> 647 void G4GDMLReadSolids:: >> 648 MultiUnionRead(const xercesc::DOMElement* const unionElement) >> 649 { >> 650 G4String name; >> 651 >> 652 const xercesc::DOMNamedNodeMap* const attributes >> 653 = unionElement->getAttributes(); >> 654 XMLSize_t attributeCount = attributes->getLength(); >> 655 >> 656 for (XMLSize_t attribute_index=0; >> 657 attribute_index<attributeCount; attribute_index++) >> 658 { >> 659 xercesc::DOMNode* attribute_node = attributes->item(attribute_index); >> 660 >> 661 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE) >> 662 { continue; } >> 663 >> 664 const xercesc::DOMAttr* const attribute >> 665 = dynamic_cast<xercesc::DOMAttr*>(attribute_node); >> 666 if (!attribute) >> 667 { >> 668 G4Exception("G4GDMLReadSolids::MultiUnionRead()", >> 669 "InvalidRead", FatalException, "No attribute found!"); >> 670 return; >> 671 } >> 672 const G4String attName = Transcode(attribute->getName()); >> 673 const G4String attValue = Transcode(attribute->getValue()); >> 674 >> 675 if (attName=="name") { name = GenerateName(attValue); } >> 676 } >> 677 >> 678 G4MultiUnion* multiUnion = new G4MultiUnion(name); >> 679 >> 680 for (xercesc::DOMNode* iter = unionElement->getFirstChild(); >> 681 iter != 0;iter = iter->getNextSibling()) >> 682 { >> 683 if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE) { continue; } >> 684 >> 685 const xercesc::DOMElement* const child >> 686 = dynamic_cast<xercesc::DOMElement*>(iter); >> 687 if (!child) >> 688 { >> 689 G4Exception("G4GDMLReadSolids::MultiUnionRead()", >> 690 "InvalidRead", FatalException, "No child found!"); >> 691 return; >> 692 } >> 693 const G4String tag = Transcode(child->getTagName()); >> 694 >> 695 if (tag=="multiUnionNode") { MultiUnionNodeRead(child, multiUnion); } >> 696 else >> 697 { >> 698 G4String error_msg = "Unknown tag in MultiUnion structure: " + tag; >> 699 G4Exception("G4GDMLReadSolids::MultiUnionRead()", "ReadError", >> 700 FatalException, error_msg); >> 701 } >> 702 } >> 703 multiUnion->Voxelize(); 1901 } 704 } 1902 705 1903 // ------------------------------------------ << 706 void G4GDMLReadSolids::OrbRead(const xercesc::DOMElement* const orbElement) 1904 G4ExtrudedSolid::ZSection G4GDMLReadSolids::S << 1905 const xercesc::DOMElement* const sectionEle << 1906 { 707 { 1907 G4double zPosition = 0.0; << 708 G4String name; 1908 G4TwoVector Offset; << 709 G4double lunit = 1.0; 1909 G4double scalingFactor = 1.0; << 710 G4double r = 0.0; 1910 << 711 1911 const xercesc::DOMNamedNodeMap* const attri << 712 const xercesc::DOMNamedNodeMap* const attributes 1912 sectionElement->getAttributes(); << 713 = orbElement->getAttributes(); 1913 XMLSize_t attributeCount = attributes->getL << 714 XMLSize_t attributeCount = attributes->getLength(); 1914 << 715 1915 for(XMLSize_t attribute_index = 0; attribut << 716 for (XMLSize_t attribute_index=0; 1916 ++attribute_index) << 717 attribute_index<attributeCount; attribute_index++) 1917 { << 718 { 1918 xercesc::DOMNode* attribute_node = attrib << 719 xercesc::DOMNode* attribute_node = attributes->item(attribute_index); 1919 << 720 1920 if(attribute_node->getNodeType() != xerce << 721 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE) 1921 { << 722 { continue; } 1922 continue; << 723 1923 } << 724 const xercesc::DOMAttr* const attribute 1924 << 725 = dynamic_cast<xercesc::DOMAttr*>(attribute_node); 1925 const xercesc::DOMAttr* const attribute = << 726 if (!attribute) 1926 dynamic_cast<xercesc::DOMAttr*>(attribu << 727 { 1927 if(attribute == nullptr) << 728 G4Exception("G4GDMLReadSolids::OrbRead()", 1928 { << 729 "InvalidRead", FatalException, "No attribute found!"); 1929 G4Exception("G4GDMLReadSolids::SectionR << 730 return; 1930 FatalException, "No attribu << 731 } 1931 return G4ExtrudedSolid::ZSection(zPosit << 732 const G4String attName = Transcode(attribute->getName()); 1932 } << 733 const G4String attValue = Transcode(attribute->getValue()); 1933 const G4String attName = Transcode(attri << 734 1934 const G4String attValue = Transcode(attri << 735 if (attName=="name") { name = GenerateName(attValue); } else 1935 << 736 if (attName=="lunit") { lunit = G4UnitDefinition::GetValueOf(attValue); 1936 if(attName == "zPosition") << 737 if (G4UnitDefinition::GetCategory(attValue)!="Length") { 1937 { << 738 G4Exception("G4GDMLReadSolids::OrbRead()", "InvalidRead", 1938 zPosition = eval.Evaluate(attValue) * l << 739 FatalException, "Invalid unit for length!"); } 1939 } << 740 } else 1940 else if(attName == "xOffset") << 741 if (attName=="r") { r = eval.Evaluate(attValue); } 1941 { << 742 } 1942 Offset.setX(eval.Evaluate(attValue) * l << 1943 } << 1944 else if(attName == "yOffset") << 1945 { << 1946 Offset.setY(eval.Evaluate(attValue) * l << 1947 } << 1948 else if(attName == "scalingFactor") << 1949 { << 1950 scalingFactor = eval.Evaluate(attValue) << 1951 } << 1952 } << 1953 << 1954 return G4ExtrudedSolid::ZSection(zPosition, << 1955 } << 1956 743 1957 // ------------------------------------------ << 744 r *= lunit; 1958 void G4GDMLReadSolids::SphereRead( << 1959 const xercesc::DOMElement* const sphereElem << 1960 { << 1961 G4String name; << 1962 G4double lunit = 1.0; << 1963 G4double aunit = 1.0; << 1964 G4double rmin = 0.0; << 1965 G4double rmax = 0.0; << 1966 G4double startphi = 0.0; << 1967 G4double deltaphi = 0.0; << 1968 G4double starttheta = 0.0; << 1969 G4double deltatheta = 0.0; << 1970 << 1971 const xercesc::DOMNamedNodeMap* const attri << 1972 sphereElement->getAttributes(); << 1973 XMLSize_t attributeCount = attributes->getL << 1974 << 1975 for(XMLSize_t attribute_index = 0; attribut << 1976 ++attribute_index) << 1977 { << 1978 xercesc::DOMNode* attribute_node = attrib << 1979 << 1980 if(attribute_node->getNodeType() != xerce << 1981 { << 1982 continue; << 1983 } << 1984 << 1985 const xercesc::DOMAttr* const attribute = << 1986 dynamic_cast<xercesc::DOMAttr*>(attribu << 1987 if(attribute == nullptr) << 1988 { << 1989 G4Exception("G4GDMLReadSolids::SphereRe << 1990 FatalException, "No attribu << 1991 return; << 1992 } << 1993 const G4String attName = Transcode(attri << 1994 const G4String attValue = Transcode(attri << 1995 << 1996 if(attName == "name") << 1997 { << 1998 name = GenerateName(attValue); << 1999 } << 2000 else if(attName == "lunit") << 2001 { << 2002 lunit = G4UnitDefinition::GetValueOf(at << 2003 if(G4UnitDefinition::GetCategory(attVal << 2004 { << 2005 G4Exception("G4GDMLReadSolids::Sphere << 2006 FatalException, "Invalid << 2007 } << 2008 } << 2009 else if(attName == "aunit") << 2010 { << 2011 aunit = G4UnitDefinition::GetValueOf(at << 2012 if(G4UnitDefinition::GetCategory(attVal << 2013 { << 2014 G4Exception("G4GDMLReadSolids::Sphere << 2015 FatalException, "Invalid << 2016 } << 2017 } << 2018 else if(attName == "rmin") << 2019 { << 2020 rmin = eval.Evaluate(attValue); << 2021 } << 2022 else if(attName == "rmax") << 2023 { << 2024 rmax = eval.Evaluate(attValue); << 2025 } << 2026 else if(attName == "startphi") << 2027 { << 2028 startphi = eval.Evaluate(attValue); << 2029 } << 2030 else if(attName == "deltaphi") << 2031 { << 2032 deltaphi = eval.Evaluate(attValue); << 2033 } << 2034 else if(attName == "starttheta") << 2035 { << 2036 starttheta = eval.Evaluate(attValue); << 2037 } << 2038 else if(attName == "deltatheta") << 2039 { << 2040 deltatheta = eval.Evaluate(attValue); << 2041 } << 2042 } << 2043 << 2044 rmin *= lunit; << 2045 rmax *= lunit; << 2046 startphi *= aunit; << 2047 deltaphi *= aunit; << 2048 starttheta *= aunit; << 2049 deltatheta *= aunit; << 2050 745 2051 new G4Sphere(name, rmin, rmax, startphi, de << 746 new G4Orb(name,r); 2052 } 747 } 2053 748 2054 // ------------------------------------------ << 749 void G4GDMLReadSolids::ParaRead(const xercesc::DOMElement* const paraElement) 2055 void G4GDMLReadSolids::TessellatedRead( << 2056 const xercesc::DOMElement* const tessellate << 2057 { 750 { 2058 G4String name; << 751 G4String name; 2059 << 752 G4double lunit = 1.0; 2060 const xercesc::DOMNamedNodeMap* const attri << 753 G4double aunit = 1.0; 2061 tessellatedElement->getAttributes(); << 754 G4double x = 0.0; 2062 XMLSize_t attributeCount = attributes->getL << 755 G4double y = 0.0; 2063 << 756 G4double z = 0.0; 2064 for(XMLSize_t attribute_index = 0; attribut << 757 G4double alpha = 0.0; 2065 ++attribute_index) << 758 G4double theta = 0.0; 2066 { << 759 G4double phi = 0.0; 2067 xercesc::DOMNode* attribute_node = attrib << 760 2068 << 761 const xercesc::DOMNamedNodeMap* const attributes 2069 if(attribute_node->getNodeType() != xerce << 762 = paraElement->getAttributes(); 2070 { << 763 XMLSize_t attributeCount = attributes->getLength(); 2071 continue; << 764 2072 } << 765 for (XMLSize_t attribute_index=0; 2073 << 766 attribute_index<attributeCount; attribute_index++) 2074 const xercesc::DOMAttr* const attribute = << 767 { 2075 dynamic_cast<xercesc::DOMAttr*>(attribu << 768 xercesc::DOMNode* attribute_node = attributes->item(attribute_index); 2076 if(attribute == nullptr) << 769 2077 { << 770 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE) 2078 G4Exception("G4GDMLReadSolids::Tessella << 771 { continue; } 2079 FatalException, "No attribu << 772 2080 return; << 773 const xercesc::DOMAttr* const attribute 2081 } << 774 = dynamic_cast<xercesc::DOMAttr*>(attribute_node); 2082 const G4String attName = Transcode(attri << 775 if (!attribute) 2083 const G4String attValue = Transcode(attri << 776 { 2084 << 777 G4Exception("G4GDMLReadSolids::ParaRead()", 2085 if(attName == "name") << 778 "InvalidRead", FatalException, "No attribute found!"); 2086 { << 779 return; 2087 name = GenerateName(attValue); << 780 } 2088 } << 781 const G4String attName = Transcode(attribute->getName()); 2089 } << 782 const G4String attValue = Transcode(attribute->getValue()); 2090 << 783 2091 G4TessellatedSolid* tessellated = new G4Tes << 784 if (attName=="name") { name = GenerateName(attValue); } else 2092 << 785 if (attName=="lunit") { lunit = G4UnitDefinition::GetValueOf(attValue); 2093 for(xercesc::DOMNode* iter = tessellatedEle << 786 if (G4UnitDefinition::GetCategory(attValue)!="Length") { 2094 iter != nullptr; iter << 787 G4Exception("G4GDMLReadSolids::ParaRead()", "InvalidRead", 2095 { << 788 FatalException, "Invalid unit for length!"); } 2096 if(iter->getNodeType() != xercesc::DOMNod << 789 } else 2097 { << 790 if (attName=="aunit") { aunit = G4UnitDefinition::GetValueOf(attValue); 2098 continue; << 791 if (G4UnitDefinition::GetCategory(attValue)!="Angle") { 2099 } << 792 G4Exception("G4GDMLReadSolids::ParaRead()", "InvalidRead", 2100 << 793 FatalException, "Invalid unit for angle!"); } 2101 const xercesc::DOMElement* const child = << 794 } else 2102 dynamic_cast<xercesc::DOMElement*>(iter << 795 if (attName=="x") { x = eval.Evaluate(attValue); } else 2103 if(child == nullptr) << 796 if (attName=="y") { y = eval.Evaluate(attValue); } else 2104 { << 797 if (attName=="z") { z = eval.Evaluate(attValue); } else 2105 G4Exception("G4GDMLReadSolids::Tessella << 798 if (attName=="alpha") { alpha = eval.Evaluate(attValue); } else 2106 FatalException, "No child f << 799 if (attName=="theta") { theta = eval.Evaluate(attValue); } else 2107 return; << 800 if (attName=="phi") { phi = eval.Evaluate(attValue); } 2108 } << 801 } 2109 const G4String tag = Transcode(child->get << 802 2110 << 803 x *= 0.5*lunit; 2111 if(tag == "triangular") << 804 y *= 0.5*lunit; 2112 { << 805 z *= 0.5*lunit; 2113 tessellated->AddFacet(TriangularRead(ch << 806 alpha *= aunit; 2114 } << 807 theta *= aunit; 2115 else if(tag == "quadrangular") << 808 phi *= aunit; 2116 { << 809 2117 tessellated->AddFacet(QuadrangularRead( << 810 new G4Para(name,x,y,z,alpha,theta,phi); 2118 } << 811 } 2119 } << 812 >> 813 void G4GDMLReadSolids:: >> 814 ParaboloidRead(const xercesc::DOMElement* const paraElement) >> 815 { >> 816 G4String name; >> 817 G4double lunit = 1.0; >> 818 G4double rlo = 0.0; >> 819 G4double rhi = 0.0; >> 820 G4double dz = 0.0; >> 821 >> 822 const xercesc::DOMNamedNodeMap* const attributes >> 823 = paraElement->getAttributes(); >> 824 XMLSize_t attributeCount = attributes->getLength(); >> 825 >> 826 for (XMLSize_t attribute_index=0; >> 827 attribute_index<attributeCount; attribute_index++) >> 828 { >> 829 xercesc::DOMNode* attribute_node = attributes->item(attribute_index); >> 830 >> 831 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE) >> 832 { continue; } >> 833 >> 834 const xercesc::DOMAttr* const attribute >> 835 = dynamic_cast<xercesc::DOMAttr*>(attribute_node); >> 836 if (!attribute) >> 837 { >> 838 G4Exception("G4GDMLReadSolids::ParaboloidRead()", >> 839 "InvalidRead", FatalException, "No attribute found!"); >> 840 return; >> 841 } >> 842 const G4String attName = Transcode(attribute->getName()); >> 843 const G4String attValue = Transcode(attribute->getValue()); >> 844 >> 845 if (attName=="name") { name = GenerateName(attValue); } else >> 846 if (attName=="lunit") { lunit = G4UnitDefinition::GetValueOf(attValue); >> 847 if (G4UnitDefinition::GetCategory(attValue)!="Length") { >> 848 G4Exception("G4GDMLReadSolids::ParaboloidRead()", "InvalidRead", >> 849 FatalException, "Invalid unit for length!"); } >> 850 } else >> 851 if (attName=="rlo") { rlo = eval.Evaluate(attValue); } else >> 852 if (attName=="rhi") { rhi = eval.Evaluate(attValue); } else >> 853 if (attName=="dz") { dz = eval.Evaluate(attValue); } >> 854 } >> 855 >> 856 rlo *= 1.*lunit; >> 857 rhi *= 1.*lunit; >> 858 dz *= 1.*lunit; >> 859 >> 860 new G4Paraboloid(name,dz,rlo,rhi); >> 861 } >> 862 >> 863 void G4GDMLReadSolids:: >> 864 PolyconeRead(const xercesc::DOMElement* const polyconeElement) >> 865 { >> 866 G4String name; >> 867 G4double lunit = 1.0; >> 868 G4double aunit = 1.0; >> 869 G4double startphi = 0.0; >> 870 G4double deltaphi = 0.0; >> 871 >> 872 const xercesc::DOMNamedNodeMap* const attributes >> 873 = polyconeElement->getAttributes(); >> 874 XMLSize_t attributeCount = attributes->getLength(); >> 875 >> 876 for (XMLSize_t attribute_index=0; >> 877 attribute_index<attributeCount; attribute_index++) >> 878 { >> 879 xercesc::DOMNode* attribute_node = attributes->item(attribute_index); >> 880 >> 881 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE) >> 882 { continue; } >> 883 >> 884 const xercesc::DOMAttr* const attribute >> 885 = dynamic_cast<xercesc::DOMAttr*>(attribute_node); >> 886 if (!attribute) >> 887 { >> 888 G4Exception("G4GDMLReadSolids::PolyconeRead()", >> 889 "InvalidRead", FatalException, "No attribute found!"); >> 890 return; >> 891 } >> 892 const G4String attName = Transcode(attribute->getName()); >> 893 const G4String attValue = Transcode(attribute->getValue()); >> 894 >> 895 if (attName=="name") { name = GenerateName(attValue); } else >> 896 if (attName=="lunit") { lunit = G4UnitDefinition::GetValueOf(attValue); >> 897 if (G4UnitDefinition::GetCategory(attValue)!="Length") { >> 898 G4Exception("G4GDMLReadSolids::PolyconeRead()", "InvalidRead", >> 899 FatalException, "Invalid unit for length!"); } >> 900 } else >> 901 if (attName=="aunit") { aunit = G4UnitDefinition::GetValueOf(attValue); >> 902 if (G4UnitDefinition::GetCategory(attValue)!="Angle") { >> 903 G4Exception("G4GDMLReadSolids::PolyconeRead()", "InvalidRead", >> 904 FatalException, "Invalid unit for angle!"); } >> 905 } else >> 906 if (attName=="startphi") { startphi = eval.Evaluate(attValue); }else >> 907 if (attName=="deltaphi") { deltaphi = eval.Evaluate(attValue); } >> 908 } >> 909 >> 910 startphi *= aunit; >> 911 deltaphi *= aunit; >> 912 >> 913 std::vector<zplaneType> zplaneList; >> 914 >> 915 for (xercesc::DOMNode* iter = polyconeElement->getFirstChild(); >> 916 iter != 0; iter = iter->getNextSibling()) >> 917 { >> 918 if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE) { continue; } >> 919 >> 920 const xercesc::DOMElement* const child >> 921 = dynamic_cast<xercesc::DOMElement*>(iter); >> 922 if (!child) >> 923 { >> 924 G4Exception("G4GDMLReadSolids::PolyconeRead()", >> 925 "InvalidRead", FatalException, "No child found!"); >> 926 return; >> 927 } >> 928 const G4String tag = Transcode(child->getTagName()); >> 929 >> 930 if (tag=="zplane") { zplaneList.push_back(ZplaneRead(child)); } >> 931 } >> 932 >> 933 G4int numZPlanes = zplaneList.size(); >> 934 >> 935 G4double* rmin_array = new G4double[numZPlanes]; >> 936 G4double* rmax_array = new G4double[numZPlanes]; >> 937 G4double* z_array = new G4double[numZPlanes]; >> 938 >> 939 for (G4int i=0; i<numZPlanes; i++) >> 940 { >> 941 rmin_array[i] = zplaneList[i].rmin*lunit; >> 942 rmax_array[i] = zplaneList[i].rmax*lunit; >> 943 z_array[i] = zplaneList[i].z*lunit; >> 944 } >> 945 >> 946 new G4Polycone(name,startphi,deltaphi,numZPlanes, >> 947 z_array,rmin_array,rmax_array); >> 948 >> 949 delete [] rmin_array; >> 950 delete [] rmax_array; >> 951 delete [] z_array; >> 952 } >> 953 >> 954 void G4GDMLReadSolids:: >> 955 GenericPolyconeRead(const xercesc::DOMElement* const polyconeElement) >> 956 { >> 957 G4String name; >> 958 G4double lunit = 1.0; >> 959 G4double aunit = 1.0; >> 960 G4double startphi = 0.0; >> 961 G4double deltaphi = 0.0; >> 962 >> 963 const xercesc::DOMNamedNodeMap* const attributes >> 964 = polyconeElement->getAttributes(); >> 965 XMLSize_t attributeCount = attributes->getLength(); >> 966 >> 967 for (XMLSize_t attribute_index=0; >> 968 attribute_index<attributeCount; attribute_index++) >> 969 { >> 970 xercesc::DOMNode* attribute_node = attributes->item(attribute_index); >> 971 >> 972 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE) >> 973 { continue; } >> 974 >> 975 const xercesc::DOMAttr* const attribute >> 976 = dynamic_cast<xercesc::DOMAttr*>(attribute_node); >> 977 if (!attribute) >> 978 { >> 979 G4Exception("G4GDMLReadSolids::GenericPolyconeRead()", >> 980 "InvalidRead", FatalException, "No attribute found!"); >> 981 return; >> 982 } >> 983 const G4String attName = Transcode(attribute->getName()); >> 984 const G4String attValue = Transcode(attribute->getValue()); >> 985 >> 986 if (attName=="name") { name = GenerateName(attValue); } else >> 987 if (attName=="lunit") { lunit = G4UnitDefinition::GetValueOf(attValue); >> 988 if (G4UnitDefinition::GetCategory(attValue)!="Length") { >> 989 G4Exception("G4GDMLReadSolids::GenericPolyconeRead()", "InvalidRead", >> 990 FatalException, "Invalid unit for length!"); } >> 991 } else >> 992 if (attName=="aunit") { aunit = G4UnitDefinition::GetValueOf(attValue); >> 993 if (G4UnitDefinition::GetCategory(attValue)!="Angle") { >> 994 G4Exception("G4GDMLReadSolids::GenericPolyconeRead()", "InvalidRead", >> 995 FatalException, "Invalid unit for angle!"); } >> 996 } else >> 997 if (attName=="startphi") { startphi = eval.Evaluate(attValue); }else >> 998 if (attName=="deltaphi") { deltaphi = eval.Evaluate(attValue); } >> 999 } >> 1000 >> 1001 startphi *= aunit; >> 1002 deltaphi *= aunit; >> 1003 >> 1004 std::vector<rzPointType> rzPointList; >> 1005 >> 1006 for (xercesc::DOMNode* iter = polyconeElement->getFirstChild(); >> 1007 iter != 0; iter = iter->getNextSibling()) >> 1008 { >> 1009 if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE) { continue; } >> 1010 >> 1011 const xercesc::DOMElement* const child >> 1012 = dynamic_cast<xercesc::DOMElement*>(iter); >> 1013 if (!child) >> 1014 { >> 1015 G4Exception("G4GDMLReadSolids::GenericPolyconeRead()", >> 1016 "InvalidRead", FatalException, "No child found!"); >> 1017 return; >> 1018 } >> 1019 const G4String tag = Transcode(child->getTagName()); >> 1020 >> 1021 if (tag=="rzpoint") { rzPointList.push_back(RZPointRead(child)); } >> 1022 } >> 1023 >> 1024 G4int numRZPoints = rzPointList.size(); >> 1025 >> 1026 G4double* r_array = new G4double[numRZPoints]; >> 1027 G4double* z_array = new G4double[numRZPoints]; >> 1028 >> 1029 for (G4int i=0; i<numRZPoints; i++) >> 1030 { >> 1031 r_array[i] = rzPointList[i].r*lunit; >> 1032 z_array[i] = rzPointList[i].z*lunit; >> 1033 } >> 1034 new G4GenericPolycone(name,startphi,deltaphi,numRZPoints, >> 1035 r_array,z_array); >> 1036 delete [] r_array; >> 1037 delete [] z_array; >> 1038 } >> 1039 >> 1040 void G4GDMLReadSolids:: >> 1041 PolyhedraRead(const xercesc::DOMElement* const polyhedraElement) >> 1042 { >> 1043 G4String name; >> 1044 G4double lunit = 1.0; >> 1045 G4double aunit = 1.0; >> 1046 G4double startphi = 0.0; >> 1047 G4double deltaphi = 0.0; >> 1048 G4int numsides = 0; >> 1049 >> 1050 const xercesc::DOMNamedNodeMap* const attributes >> 1051 = polyhedraElement->getAttributes(); >> 1052 XMLSize_t attributeCount = attributes->getLength(); >> 1053 >> 1054 for (XMLSize_t attribute_index=0; >> 1055 attribute_index<attributeCount; attribute_index++) >> 1056 { >> 1057 xercesc::DOMNode* attribute_node = attributes->item(attribute_index); >> 1058 >> 1059 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE) >> 1060 { continue; } >> 1061 >> 1062 const xercesc::DOMAttr* const attribute >> 1063 = dynamic_cast<xercesc::DOMAttr*>(attribute_node); >> 1064 if (!attribute) >> 1065 { >> 1066 G4Exception("G4GDMLReadSolids::PolyhedraRead()", >> 1067 "InvalidRead", FatalException, "No attribute found!"); >> 1068 return; >> 1069 } >> 1070 const G4String attName = Transcode(attribute->getName()); >> 1071 const G4String attValue = Transcode(attribute->getValue()); >> 1072 >> 1073 if (attName=="name") { name = GenerateName(attValue); } else >> 1074 if (attName=="lunit") { lunit = G4UnitDefinition::GetValueOf(attValue); >> 1075 if (G4UnitDefinition::GetCategory(attValue)!="Length") { >> 1076 G4Exception("G4GDMLReadSolids::PolyhedraRead()", "InvalidRead", >> 1077 FatalException, "Invalid unit for length!"); } >> 1078 } else >> 1079 if (attName=="aunit") { aunit = G4UnitDefinition::GetValueOf(attValue); >> 1080 if (G4UnitDefinition::GetCategory(attValue)!="Angle") { >> 1081 G4Exception("G4GDMLReadSolids::PolyhedraRead()", "InvalidRead", >> 1082 FatalException, "Invalid unit for angle!"); } >> 1083 } else >> 1084 if (attName=="startphi") { startphi = eval.Evaluate(attValue); } else >> 1085 if (attName=="deltaphi") { deltaphi = eval.Evaluate(attValue); } else >> 1086 if (attName=="numsides") { numsides = eval.EvaluateInteger(attValue); } >> 1087 } >> 1088 >> 1089 startphi *= aunit; >> 1090 deltaphi *= aunit; >> 1091 >> 1092 std::vector<zplaneType> zplaneList; >> 1093 >> 1094 for (xercesc::DOMNode* iter = polyhedraElement->getFirstChild(); >> 1095 iter != 0; iter = iter->getNextSibling()) >> 1096 { >> 1097 if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE) { continue; } >> 1098 >> 1099 const xercesc::DOMElement* const child >> 1100 = dynamic_cast<xercesc::DOMElement*>(iter); >> 1101 if (!child) >> 1102 { >> 1103 G4Exception("G4GDMLReadSolids::PolyhedraRead()", >> 1104 "InvalidRead", FatalException, "No child found!"); >> 1105 return; >> 1106 } >> 1107 const G4String tag = Transcode(child->getTagName()); >> 1108 >> 1109 if (tag=="zplane") { zplaneList.push_back(ZplaneRead(child)); } >> 1110 } >> 1111 >> 1112 G4int numZPlanes = zplaneList.size(); >> 1113 >> 1114 G4double* rmin_array = new G4double[numZPlanes]; >> 1115 G4double* rmax_array = new G4double[numZPlanes]; >> 1116 G4double* z_array = new G4double[numZPlanes]; >> 1117 >> 1118 for (G4int i=0; i<numZPlanes; i++) >> 1119 { >> 1120 rmin_array[i] = zplaneList[i].rmin*lunit; >> 1121 rmax_array[i] = zplaneList[i].rmax*lunit; >> 1122 z_array[i] = zplaneList[i].z*lunit; >> 1123 } >> 1124 >> 1125 new G4Polyhedra(name,startphi,deltaphi,numsides,numZPlanes, >> 1126 z_array,rmin_array,rmax_array); >> 1127 >> 1128 delete [] rmin_array; >> 1129 delete [] rmax_array; >> 1130 delete [] z_array; >> 1131 } >> 1132 >> 1133 void G4GDMLReadSolids:: >> 1134 GenericPolyhedraRead(const xercesc::DOMElement* const polyhedraElement) >> 1135 { >> 1136 G4String name; >> 1137 G4double lunit = 1.0; >> 1138 G4double aunit = 1.0; >> 1139 G4double startphi = 0.0; >> 1140 G4double deltaphi = 0.0; >> 1141 G4int numsides = 0; >> 1142 >> 1143 const xercesc::DOMNamedNodeMap* const attributes >> 1144 = polyhedraElement->getAttributes(); >> 1145 XMLSize_t attributeCount = attributes->getLength(); >> 1146 >> 1147 for (XMLSize_t attribute_index=0; >> 1148 attribute_index<attributeCount; attribute_index++) >> 1149 { >> 1150 xercesc::DOMNode* attribute_node = attributes->item(attribute_index); >> 1151 >> 1152 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE) >> 1153 { continue; } >> 1154 >> 1155 const xercesc::DOMAttr* const attribute >> 1156 = dynamic_cast<xercesc::DOMAttr*>(attribute_node); >> 1157 if (!attribute) >> 1158 { >> 1159 G4Exception("G4GDMLReadSolids::GenericPolyhedraRead()", >> 1160 "InvalidRead", FatalException, "No attribute found!"); >> 1161 return; >> 1162 } >> 1163 const G4String attName = Transcode(attribute->getName()); >> 1164 const G4String attValue = Transcode(attribute->getValue()); >> 1165 >> 1166 if (attName=="name") { name = GenerateName(attValue); } else >> 1167 if (attName=="lunit") { lunit = G4UnitDefinition::GetValueOf(attValue); >> 1168 if (G4UnitDefinition::GetCategory(attValue)!="Length") { >> 1169 G4Exception("G4GDMLReadSolids::GenericPolyhedraRead()", "InvalidRead", >> 1170 FatalException, "Invalid unit for length!"); } >> 1171 } else >> 1172 if (attName=="aunit") { aunit = G4UnitDefinition::GetValueOf(attValue); >> 1173 if (G4UnitDefinition::GetCategory(attValue)!="Angle") { >> 1174 G4Exception("G4GDMLReadSolids::GenericPolyhedraRead()", "InvalidRead", >> 1175 FatalException, "Invalid unit for angle!"); } >> 1176 } else >> 1177 if (attName=="startphi") { startphi = eval.Evaluate(attValue); } else >> 1178 if (attName=="deltaphi") { deltaphi = eval.Evaluate(attValue); } else >> 1179 if (attName=="numsides") { numsides = eval.EvaluateInteger(attValue); } >> 1180 } >> 1181 >> 1182 startphi *= aunit; >> 1183 deltaphi *= aunit; >> 1184 >> 1185 std::vector<rzPointType> rzpointList; >> 1186 >> 1187 for (xercesc::DOMNode* iter = polyhedraElement->getFirstChild(); >> 1188 iter != 0; iter = iter->getNextSibling()) >> 1189 { >> 1190 if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE) { continue; } >> 1191 >> 1192 const xercesc::DOMElement* const child >> 1193 = dynamic_cast<xercesc::DOMElement*>(iter); >> 1194 if (!child) >> 1195 { >> 1196 G4Exception("G4GDMLReadSolids::GenericPolyhedraRead()", >> 1197 "InvalidRead", FatalException, "No child found!"); >> 1198 return; >> 1199 } >> 1200 const G4String tag = Transcode(child->getTagName()); >> 1201 >> 1202 if (tag=="rzpoint") { rzpointList.push_back(RZPointRead(child)); } >> 1203 } >> 1204 >> 1205 G4int numRZPoints = rzpointList.size(); >> 1206 >> 1207 G4double* r_array = new G4double[numRZPoints]; >> 1208 G4double* z_array = new G4double[numRZPoints]; >> 1209 >> 1210 for (G4int i=0; i<numRZPoints; i++) >> 1211 { >> 1212 r_array[i] = rzpointList[i].r*lunit; >> 1213 z_array[i] = rzpointList[i].z*lunit; >> 1214 } >> 1215 >> 1216 new G4Polyhedra(name,startphi,deltaphi,numsides,numRZPoints, >> 1217 r_array,z_array); >> 1218 >> 1219 delete [] r_array; >> 1220 delete [] z_array; >> 1221 } >> 1222 >> 1223 G4QuadrangularFacet* G4GDMLReadSolids:: >> 1224 QuadrangularRead(const xercesc::DOMElement* const quadrangularElement) >> 1225 { >> 1226 G4ThreeVector vertex1; >> 1227 G4ThreeVector vertex2; >> 1228 G4ThreeVector vertex3; >> 1229 G4ThreeVector vertex4; >> 1230 G4FacetVertexType type = ABSOLUTE; >> 1231 G4double lunit = 1.0; >> 1232 >> 1233 const xercesc::DOMNamedNodeMap* const attributes >> 1234 = quadrangularElement->getAttributes(); >> 1235 XMLSize_t attributeCount = attributes->getLength(); >> 1236 >> 1237 for (XMLSize_t attribute_index=0; >> 1238 attribute_index<attributeCount; attribute_index++) >> 1239 { >> 1240 xercesc::DOMNode* attribute_node = attributes->item(attribute_index); >> 1241 >> 1242 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE) >> 1243 { continue; } >> 1244 >> 1245 const xercesc::DOMAttr* const attribute >> 1246 = dynamic_cast<xercesc::DOMAttr*>(attribute_node); >> 1247 if (!attribute) >> 1248 { >> 1249 G4Exception("G4GDMLReadSolids::QuadrangularRead()", >> 1250 "InvalidRead", FatalException, "No attribute found!"); >> 1251 return 0; >> 1252 } >> 1253 const G4String attName = Transcode(attribute->getName()); >> 1254 const G4String attValue = Transcode(attribute->getValue()); >> 1255 >> 1256 if (attName=="vertex1") >> 1257 { vertex1 = GetPosition(GenerateName(attValue)); } else >> 1258 if (attName=="vertex2") >> 1259 { vertex2 = GetPosition(GenerateName(attValue)); } else >> 1260 if (attName=="vertex3") >> 1261 { vertex3 = GetPosition(GenerateName(attValue)); } else >> 1262 if (attName=="vertex4") >> 1263 { vertex4 = GetPosition(GenerateName(attValue)); } else >> 1264 if (attName=="lunit") >> 1265 { lunit = G4UnitDefinition::GetValueOf(attValue); >> 1266 if (G4UnitDefinition::GetCategory(attValue)!="Length") { >> 1267 G4Exception("G4GDMLReadSolids::QuadrangularRead()", "InvalidRead", >> 1268 FatalException, "Invalid unit for length!"); } >> 1269 } else >> 1270 if (attName=="type") >> 1271 { if (attValue=="RELATIVE") { type = RELATIVE; } } >> 1272 } >> 1273 >> 1274 return new G4QuadrangularFacet(vertex1*lunit,vertex2*lunit, >> 1275 vertex3*lunit,vertex4*lunit,type); >> 1276 } >> 1277 >> 1278 void G4GDMLReadSolids:: >> 1279 ReflectedSolidRead(const xercesc::DOMElement* const reflectedSolidElement) >> 1280 { >> 1281 G4String name; >> 1282 G4double lunit = 1.0; >> 1283 G4double aunit = 1.0; >> 1284 G4String solid; >> 1285 G4ThreeVector scale(1.0,1.0,1.0); >> 1286 G4ThreeVector rotation; >> 1287 G4ThreeVector position; >> 1288 >> 1289 const xercesc::DOMNamedNodeMap* const attributes >> 1290 = reflectedSolidElement->getAttributes(); >> 1291 XMLSize_t attributeCount = attributes->getLength(); >> 1292 >> 1293 for (XMLSize_t attribute_index=0; >> 1294 attribute_index<attributeCount; attribute_index++) >> 1295 { >> 1296 xercesc::DOMNode* attribute_node = attributes->item(attribute_index); >> 1297 >> 1298 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE) >> 1299 { continue; } >> 1300 >> 1301 const xercesc::DOMAttr* const attribute >> 1302 = dynamic_cast<xercesc::DOMAttr*>(attribute_node); >> 1303 if (!attribute) >> 1304 { >> 1305 G4Exception("G4GDMLReadSolids::ReflectedSolidRead()", >> 1306 "InvalidRead", FatalException, "No attribute found!"); >> 1307 return; >> 1308 } >> 1309 const G4String attName = Transcode(attribute->getName()); >> 1310 const G4String attValue = Transcode(attribute->getValue()); >> 1311 >> 1312 if (attName=="name") { name = GenerateName(attValue); } else >> 1313 if (attName=="lunit") { lunit = G4UnitDefinition::GetValueOf(attValue); >> 1314 if (G4UnitDefinition::GetCategory(attValue)!="Length") { >> 1315 G4Exception("G4GDMLReadSolids::ReflectedSolidRead()", "InvalidRead", >> 1316 FatalException, "Invalid unit for length!"); } >> 1317 } else >> 1318 if (attName=="aunit") { aunit = G4UnitDefinition::GetValueOf(attValue); >> 1319 if (G4UnitDefinition::GetCategory(attValue)!="Angle") { >> 1320 G4Exception("G4GDMLReadSolids::ReflectedSolidRead()", "InvalidRead", >> 1321 FatalException, "Invalid unit for angle!"); } >> 1322 } else >> 1323 if (attName=="solid") { solid = GenerateName(attValue); } else >> 1324 if (attName=="sx") { scale.setX(eval.Evaluate(attValue)); } else >> 1325 if (attName=="sy") { scale.setY(eval.Evaluate(attValue)); } else >> 1326 if (attName=="sz") { scale.setZ(eval.Evaluate(attValue)); } else >> 1327 if (attName=="rx") { rotation.setX(eval.Evaluate(attValue)); } else >> 1328 if (attName=="ry") { rotation.setY(eval.Evaluate(attValue)); } else >> 1329 if (attName=="rz") { rotation.setZ(eval.Evaluate(attValue)); } else >> 1330 if (attName=="dx") { position.setX(eval.Evaluate(attValue)); } else >> 1331 if (attName=="dy") { position.setY(eval.Evaluate(attValue)); } else >> 1332 if (attName=="dz") { position.setZ(eval.Evaluate(attValue)); } >> 1333 } >> 1334 >> 1335 rotation *= aunit; >> 1336 position *= lunit; >> 1337 >> 1338 G4Transform3D transform(GetRotationMatrix(rotation),position); >> 1339 transform = transform*G4Scale3D(scale.x(),scale.y(),scale.z()); >> 1340 >> 1341 new G4ReflectedSolid(name,GetSolid(solid),transform); >> 1342 } >> 1343 >> 1344 void G4GDMLReadSolids:: >> 1345 ScaledSolidRead(const xercesc::DOMElement* const scaledSolidElement) >> 1346 { >> 1347 G4String name; >> 1348 G4VSolid* solid=0; >> 1349 G4ThreeVector scale(1.0,1.0,1.0); >> 1350 >> 1351 const xercesc::DOMNamedNodeMap* const attributes >> 1352 = scaledSolidElement->getAttributes(); >> 1353 XMLSize_t attributeCount = attributes->getLength(); >> 1354 >> 1355 for (XMLSize_t attribute_index=0; >> 1356 attribute_index<attributeCount; attribute_index++) >> 1357 { >> 1358 xercesc::DOMNode* attribute_node = attributes->item(attribute_index); >> 1359 >> 1360 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE) >> 1361 { continue; } >> 1362 >> 1363 const xercesc::DOMAttr* const attribute >> 1364 = dynamic_cast<xercesc::DOMAttr*>(attribute_node); >> 1365 if (!attribute) >> 1366 { >> 1367 G4Exception("G4GDMLReadSolids::ScaledSolidRead()", >> 1368 "InvalidRead", FatalException, "No attribute found!"); >> 1369 return; >> 1370 } >> 1371 const G4String attName = Transcode(attribute->getName()); >> 1372 const G4String attValue = Transcode(attribute->getValue()); >> 1373 >> 1374 if (attName=="name") { name = GenerateName(attValue); } >> 1375 } >> 1376 >> 1377 for (xercesc::DOMNode* iter = scaledSolidElement->getFirstChild(); >> 1378 iter != 0; iter = iter->getNextSibling()) >> 1379 { >> 1380 if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE) { continue; } >> 1381 >> 1382 const xercesc::DOMElement* const child >> 1383 = dynamic_cast<xercesc::DOMElement*>(iter); >> 1384 if (!child) >> 1385 { >> 1386 G4Exception("G4GDMLReadSolids::ScaledSolidRead()", >> 1387 "InvalidRead", FatalException, "No child found!"); >> 1388 return; >> 1389 } >> 1390 const G4String tag = Transcode(child->getTagName()); >> 1391 >> 1392 if (tag=="solidref") >> 1393 { solid = GetSolid(GenerateName(RefRead(child))); } >> 1394 else if (tag=="scale") >> 1395 { VectorRead(child,scale); } >> 1396 else if (tag=="scaleref") >> 1397 { scale = GetScale(GenerateName(RefRead(child))); } >> 1398 else >> 1399 { >> 1400 G4String error_msg = "Unknown tag in scaled solid: " + tag; >> 1401 G4Exception("G4GDMLReadSolids::ScaledSolidRead()", "ReadError", >> 1402 FatalException, error_msg); >> 1403 return; >> 1404 } >> 1405 } >> 1406 >> 1407 G4Scale3D transform = G4Scale3D(scale.x(),scale.y(),scale.z()); >> 1408 >> 1409 new G4ScaledSolid(name, solid ,transform); >> 1410 } >> 1411 >> 1412 G4ExtrudedSolid::ZSection G4GDMLReadSolids:: >> 1413 SectionRead(const xercesc::DOMElement* const sectionElement,G4double lunit) >> 1414 { >> 1415 G4double zPosition = 0.0; >> 1416 G4TwoVector Offset; >> 1417 G4double scalingFactor = 1.0; >> 1418 >> 1419 const xercesc::DOMNamedNodeMap* const attributes >> 1420 = sectionElement->getAttributes(); >> 1421 XMLSize_t attributeCount = attributes->getLength(); >> 1422 >> 1423 for (XMLSize_t attribute_index=0; >> 1424 attribute_index<attributeCount; attribute_index++) >> 1425 { >> 1426 xercesc::DOMNode* attribute_node = attributes->item(attribute_index); >> 1427 >> 1428 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE) >> 1429 { continue; } >> 1430 >> 1431 const xercesc::DOMAttr* const attribute >> 1432 = dynamic_cast<xercesc::DOMAttr*>(attribute_node); >> 1433 if (!attribute) >> 1434 { >> 1435 G4Exception("G4GDMLReadSolids::SectionRead()", >> 1436 "InvalidRead", FatalException, "No attribute found!"); >> 1437 return G4ExtrudedSolid::ZSection(zPosition,Offset,scalingFactor); >> 1438 } >> 1439 const G4String attName = Transcode(attribute->getName()); >> 1440 const G4String attValue = Transcode(attribute->getValue()); >> 1441 >> 1442 if (attName=="zPosition") >> 1443 { zPosition = eval.Evaluate(attValue)*lunit; } else >> 1444 if (attName=="xOffset") >> 1445 { Offset.setX(eval.Evaluate(attValue)*lunit); } else >> 1446 if (attName=="yOffset") >> 1447 { Offset.setY(eval.Evaluate(attValue)*lunit); } else >> 1448 if (attName=="scalingFactor") >> 1449 { scalingFactor = eval.Evaluate(attValue); } >> 1450 } >> 1451 >> 1452 return G4ExtrudedSolid::ZSection(zPosition,Offset,scalingFactor); >> 1453 } >> 1454 >> 1455 void G4GDMLReadSolids:: >> 1456 SphereRead(const xercesc::DOMElement* const sphereElement) >> 1457 { >> 1458 G4String name; >> 1459 G4double lunit = 1.0; >> 1460 G4double aunit = 1.0; >> 1461 G4double rmin = 0.0; >> 1462 G4double rmax = 0.0; >> 1463 G4double startphi = 0.0; >> 1464 G4double deltaphi = 0.0; >> 1465 G4double starttheta = 0.0; >> 1466 G4double deltatheta = 0.0; >> 1467 >> 1468 const xercesc::DOMNamedNodeMap* const attributes >> 1469 = sphereElement->getAttributes(); >> 1470 XMLSize_t attributeCount = attributes->getLength(); >> 1471 >> 1472 for (XMLSize_t attribute_index=0; >> 1473 attribute_index<attributeCount; attribute_index++) >> 1474 { >> 1475 xercesc::DOMNode* attribute_node = attributes->item(attribute_index); >> 1476 >> 1477 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE) >> 1478 { continue; } >> 1479 >> 1480 const xercesc::DOMAttr* const attribute >> 1481 = dynamic_cast<xercesc::DOMAttr*>(attribute_node); >> 1482 if (!attribute) >> 1483 { >> 1484 G4Exception("G4GDMLReadSolids::SphereRead()", >> 1485 "InvalidRead", FatalException, "No attribute found!"); >> 1486 return; >> 1487 } >> 1488 const G4String attName = Transcode(attribute->getName()); >> 1489 const G4String attValue = Transcode(attribute->getValue()); >> 1490 >> 1491 if (attName=="name") { name = GenerateName(attValue); } else >> 1492 if (attName=="lunit") { lunit = G4UnitDefinition::GetValueOf(attValue); >> 1493 if (G4UnitDefinition::GetCategory(attValue)!="Length") { >> 1494 G4Exception("G4GDMLReadSolids::SphereRead()", "InvalidRead", >> 1495 FatalException, "Invalid unit for length!"); } >> 1496 } else >> 1497 if (attName=="aunit") { aunit = G4UnitDefinition::GetValueOf(attValue); >> 1498 if (G4UnitDefinition::GetCategory(attValue)!="Angle") { >> 1499 G4Exception("G4GDMLReadSolids::SphereRead()", "InvalidRead", >> 1500 FatalException, "Invalid unit for angle!"); } >> 1501 } else >> 1502 if (attName=="rmin") { rmin = eval.Evaluate(attValue); } else >> 1503 if (attName=="rmax") { rmax = eval.Evaluate(attValue); } else >> 1504 if (attName=="startphi") { startphi = eval.Evaluate(attValue); } else >> 1505 if (attName=="deltaphi") { deltaphi = eval.Evaluate(attValue); } else >> 1506 if (attName=="starttheta") { starttheta = eval.Evaluate(attValue); } else >> 1507 if (attName=="deltatheta") { deltatheta = eval.Evaluate(attValue); } >> 1508 } >> 1509 >> 1510 rmin *= lunit; >> 1511 rmax *= lunit; >> 1512 startphi *= aunit; >> 1513 deltaphi *= aunit; >> 1514 starttheta *= aunit; >> 1515 deltatheta *= aunit; >> 1516 >> 1517 new G4Sphere(name,rmin,rmax,startphi,deltaphi,starttheta,deltatheta); >> 1518 } >> 1519 >> 1520 void G4GDMLReadSolids:: >> 1521 TessellatedRead(const xercesc::DOMElement* const tessellatedElement) >> 1522 { >> 1523 G4String name; >> 1524 >> 1525 const xercesc::DOMNamedNodeMap* const attributes >> 1526 = tessellatedElement->getAttributes(); >> 1527 XMLSize_t attributeCount = attributes->getLength(); >> 1528 >> 1529 for (XMLSize_t attribute_index=0; >> 1530 attribute_index<attributeCount; attribute_index++) >> 1531 { >> 1532 xercesc::DOMNode* attribute_node = attributes->item(attribute_index); >> 1533 >> 1534 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE) >> 1535 { continue; } >> 1536 >> 1537 const xercesc::DOMAttr* const attribute >> 1538 = dynamic_cast<xercesc::DOMAttr*>(attribute_node); >> 1539 if (!attribute) >> 1540 { >> 1541 G4Exception("G4GDMLReadSolids::TessellatedRead()", >> 1542 "InvalidRead", FatalException, "No attribute found!"); >> 1543 return; >> 1544 } >> 1545 const G4String attName = Transcode(attribute->getName()); >> 1546 const G4String attValue = Transcode(attribute->getValue()); >> 1547 >> 1548 if (attName=="name") { name = GenerateName(attValue); } >> 1549 } >> 1550 >> 1551 G4TessellatedSolid *tessellated = new G4TessellatedSolid(name); >> 1552 >> 1553 for (xercesc::DOMNode* iter = tessellatedElement->getFirstChild(); >> 1554 iter != 0; iter = iter->getNextSibling()) >> 1555 { >> 1556 if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE) { continue; } >> 1557 >> 1558 const xercesc::DOMElement* const child >> 1559 = dynamic_cast<xercesc::DOMElement*>(iter); >> 1560 if (!child) >> 1561 { >> 1562 G4Exception("G4GDMLReadSolids::TessellatedRead()", >> 1563 "InvalidRead", FatalException, "No child found!"); >> 1564 return; >> 1565 } >> 1566 const G4String tag = Transcode(child->getTagName()); >> 1567 >> 1568 if (tag=="triangular") >> 1569 { tessellated->AddFacet(TriangularRead(child)); } else >> 1570 if (tag=="quadrangular") >> 1571 { tessellated->AddFacet(QuadrangularRead(child)); } >> 1572 } 2120 1573 2121 tessellated->SetSolidClosed(true); << 1574 tessellated->SetSolidClosed(true); 2122 } 1575 } 2123 1576 2124 // ------------------------------------------ << 2125 void G4GDMLReadSolids::TetRead(const xercesc: 1577 void G4GDMLReadSolids::TetRead(const xercesc::DOMElement* const tetElement) 2126 { 1578 { 2127 G4String name; << 1579 G4String name; 2128 G4ThreeVector vertex1; << 1580 G4ThreeVector vertex1; 2129 G4ThreeVector vertex2; << 1581 G4ThreeVector vertex2; 2130 G4ThreeVector vertex3; << 1582 G4ThreeVector vertex3; 2131 G4ThreeVector vertex4; << 1583 G4ThreeVector vertex4; 2132 G4double lunit = 1.0; << 1584 G4double lunit = 1.0; 2133 << 1585 2134 const xercesc::DOMNamedNodeMap* const attri << 1586 const xercesc::DOMNamedNodeMap* const attributes 2135 tetElement->getAttributes(); << 1587 = tetElement->getAttributes(); 2136 XMLSize_t attributeCount = attributes->getL << 1588 XMLSize_t attributeCount = attributes->getLength(); 2137 << 1589 2138 for(XMLSize_t attribute_index = 0; attribut << 1590 for (XMLSize_t attribute_index=0; 2139 ++attribute_index) << 1591 attribute_index<attributeCount;attribute_index++) 2140 { << 1592 { 2141 xercesc::DOMNode* attribute_node = attrib << 1593 xercesc::DOMNode* attribute_node = attributes->item(attribute_index); 2142 << 1594 2143 if(attribute_node->getNodeType() != xerce << 1595 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE) 2144 { << 1596 { continue; } 2145 continue; << 1597 2146 } << 1598 const xercesc::DOMAttr* const attribute 2147 << 1599 = dynamic_cast<xercesc::DOMAttr*>(attribute_node); 2148 const xercesc::DOMAttr* const attribute = << 1600 if (!attribute) 2149 dynamic_cast<xercesc::DOMAttr*>(attribu << 1601 { 2150 if(attribute == nullptr) << 1602 G4Exception("G4GDMLReadSolids::TetRead()", 2151 { << 1603 "InvalidRead", FatalException, "No attribute found!"); 2152 G4Exception("G4GDMLReadSolids::TetRead( << 1604 return; 2153 "No attribute found!"); << 1605 } 2154 return; << 1606 const G4String attName = Transcode(attribute->getName()); 2155 } << 1607 const G4String attValue = Transcode(attribute->getValue()); 2156 const G4String attName = Transcode(attri << 1608 2157 const G4String attValue = Transcode(attri << 1609 if (attName=="name") 2158 << 1610 { name = GenerateName(attValue); } else 2159 if(attName == "name") << 1611 if (attName=="lunit") 2160 { << 1612 { lunit = G4UnitDefinition::GetValueOf(attValue); 2161 name = GenerateName(attValue); << 1613 if (G4UnitDefinition::GetCategory(attValue)!="Length") { 2162 } << 1614 G4Exception("G4GDMLReadSolids::TetRead()", "InvalidRead", 2163 else if(attName == "lunit") << 1615 FatalException, "Invalid unit for length!"); } 2164 { << 1616 } else 2165 lunit = G4UnitDefinition::GetValueOf(at << 1617 if (attName=="vertex1") 2166 if(G4UnitDefinition::GetCategory(attVal << 1618 { vertex1 = GetPosition(GenerateName(attValue)); } else 2167 { << 1619 if (attName=="vertex2") 2168 G4Exception("G4GDMLReadSolids::TetRea << 1620 { vertex2 = GetPosition(GenerateName(attValue)); } else 2169 FatalException, "Invalid << 1621 if (attName=="vertex3") 2170 } << 1622 { vertex3 = GetPosition(GenerateName(attValue)); } else 2171 } << 1623 if (attName=="vertex4") 2172 else if(attName == "vertex1") << 1624 { vertex4 = GetPosition(GenerateName(attValue)); } 2173 { << 1625 } 2174 vertex1 = GetPosition(GenerateName(attV << 2175 } << 2176 else if(attName == "vertex2") << 2177 { << 2178 vertex2 = GetPosition(GenerateName(attV << 2179 } << 2180 else if(attName == "vertex3") << 2181 { << 2182 vertex3 = GetPosition(GenerateName(attV << 2183 } << 2184 else if(attName == "vertex4") << 2185 { << 2186 vertex4 = GetPosition(GenerateName(attV << 2187 } << 2188 } << 2189 1626 2190 new G4Tet(name, vertex1 * lunit, vertex2 * << 1627 new G4Tet(name,vertex1*lunit,vertex2*lunit,vertex3*lunit,vertex4*lunit); 2191 vertex4 * lunit); << 2192 } 1628 } 2193 1629 2194 // ------------------------------------------ << 2195 void G4GDMLReadSolids::TorusRead(const xerces 1630 void G4GDMLReadSolids::TorusRead(const xercesc::DOMElement* const torusElement) 2196 { 1631 { 2197 G4String name; << 1632 G4String name; 2198 G4double lunit = 1.0; << 1633 G4double lunit = 1.0; 2199 G4double aunit = 1.0; << 1634 G4double aunit = 1.0; 2200 G4double rmin = 0.0; << 1635 G4double rmin = 0.0; 2201 G4double rmax = 0.0; << 1636 G4double rmax = 0.0; 2202 G4double rtor = 0.0; << 1637 G4double rtor = 0.0; 2203 G4double startphi = 0.0; << 1638 G4double startphi = 0.0; 2204 G4double deltaphi = 0.0; << 1639 G4double deltaphi = 0.0; 2205 << 1640 2206 const xercesc::DOMNamedNodeMap* const attri << 1641 const xercesc::DOMNamedNodeMap* const attributes 2207 torusElement->getAttributes(); << 1642 = torusElement->getAttributes(); 2208 XMLSize_t attributeCount = attributes->getL << 1643 XMLSize_t attributeCount = attributes->getLength(); 2209 << 1644 2210 for(XMLSize_t attribute_index = 0; attribut << 1645 for (XMLSize_t attribute_index=0; 2211 ++attribute_index) << 1646 attribute_index<attributeCount; attribute_index++) 2212 { << 1647 { 2213 xercesc::DOMNode* attribute_node = attrib << 1648 xercesc::DOMNode* attribute_node = attributes->item(attribute_index); 2214 << 1649 2215 if(attribute_node->getNodeType() != xerce << 1650 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE) 2216 { << 1651 { continue; } 2217 continue; << 1652 2218 } << 1653 const xercesc::DOMAttr* const attribute 2219 << 1654 = dynamic_cast<xercesc::DOMAttr*>(attribute_node); 2220 const xercesc::DOMAttr* const attribute = << 1655 if (!attribute) 2221 dynamic_cast<xercesc::DOMAttr*>(attribu << 1656 { 2222 if(attribute == nullptr) << 1657 G4Exception("G4GDMLReadSolids::TorusRead()", 2223 { << 1658 "InvalidRead", FatalException, "No attribute found!"); 2224 G4Exception("G4GDMLReadSolids::TorusRea << 1659 return; 2225 FatalException, "No attribu << 1660 } 2226 return; << 1661 const G4String attName = Transcode(attribute->getName()); 2227 } << 1662 const G4String attValue = Transcode(attribute->getValue()); 2228 const G4String attName = Transcode(attri << 1663 2229 const G4String attValue = Transcode(attri << 1664 if (attName=="name") { name = GenerateName(attValue); } else 2230 << 1665 if (attName=="lunit") { lunit = G4UnitDefinition::GetValueOf(attValue); 2231 if(attName == "name") << 1666 if (G4UnitDefinition::GetCategory(attValue)!="Length") { 2232 { << 1667 G4Exception("G4GDMLReadSolids::TorusRead()", "InvalidRead", 2233 name = GenerateName(attValue); << 1668 FatalException, "Invalid unit for length!"); } 2234 } << 1669 } else 2235 else if(attName == "lunit") << 1670 if (attName=="aunit") { aunit = G4UnitDefinition::GetValueOf(attValue); 2236 { << 1671 if (G4UnitDefinition::GetCategory(attValue)!="Angle") { 2237 lunit = G4UnitDefinition::GetValueOf(at << 1672 G4Exception("G4GDMLReadSolids::TorusRead()", "InvalidRead", 2238 if(G4UnitDefinition::GetCategory(attVal << 1673 FatalException, "Invalid unit for angle!"); } 2239 { << 1674 } else 2240 G4Exception("G4GDMLReadSolids::TorusR << 1675 if (attName=="rmin") { rmin = eval.Evaluate(attValue); } else 2241 FatalException, "Invalid << 1676 if (attName=="rmax") { rmax = eval.Evaluate(attValue); } else 2242 } << 1677 if (attName=="rtor") { rtor = eval.Evaluate(attValue); } else 2243 } << 1678 if (attName=="startphi") { startphi = eval.Evaluate(attValue); } else 2244 else if(attName == "aunit") << 1679 if (attName=="deltaphi") { deltaphi = eval.Evaluate(attValue); } 2245 { << 1680 } 2246 aunit = G4UnitDefinition::GetValueOf(at << 1681 2247 if(G4UnitDefinition::GetCategory(attVal << 1682 rmin *= lunit; 2248 { << 1683 rmax *= lunit; 2249 G4Exception("G4GDMLReadSolids::TorusR << 1684 rtor *= lunit; 2250 FatalException, "Invalid << 1685 startphi *= aunit; 2251 } << 1686 deltaphi *= aunit; 2252 } << 1687 2253 else if(attName == "rmin") << 1688 new G4Torus(name,rmin,rmax,rtor,startphi,deltaphi); 2254 { << 1689 } 2255 rmin = eval.Evaluate(attValue); << 1690 2256 } << 1691 void G4GDMLReadSolids:: 2257 else if(attName == "rmax") << 1692 GenTrapRead(const xercesc::DOMElement* const gtrapElement) 2258 { << 1693 { 2259 rmax = eval.Evaluate(attValue); << 1694 G4String name; 2260 } << 1695 G4double lunit = 1.0; 2261 else if(attName == "rtor") << 1696 G4double dz =0.0; 2262 { << 1697 G4double v1x=0.0, v1y=0.0, v2x=0.0, v2y=0.0, v3x=0.0, v3y=0.0, 2263 rtor = eval.Evaluate(attValue); << 1698 v4x=0.0, v4y=0.0, v5x=0.0, v5y=0.0, v6x=0.0, v6y=0.0, 2264 } << 1699 v7x=0.0, v7y=0.0, v8x=0.0, v8y=0.0; 2265 else if(attName == "startphi") << 1700 2266 { << 1701 const xercesc::DOMNamedNodeMap* const attributes 2267 startphi = eval.Evaluate(attValue); << 1702 = gtrapElement->getAttributes(); 2268 } << 1703 XMLSize_t attributeCount = attributes->getLength(); 2269 else if(attName == "deltaphi") << 1704 2270 { << 1705 for (XMLSize_t attribute_index=0; 2271 deltaphi = eval.Evaluate(attValue); << 1706 attribute_index<attributeCount; attribute_index++) 2272 } << 1707 { 2273 } << 1708 xercesc::DOMNode* attribute_node = attributes->item(attribute_index); 2274 << 1709 2275 rmin *= lunit; << 1710 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE) 2276 rmax *= lunit; << 1711 { continue; } 2277 rtor *= lunit; << 1712 2278 startphi *= aunit; << 1713 const xercesc::DOMAttr* const attribute 2279 deltaphi *= aunit; << 1714 = dynamic_cast<xercesc::DOMAttr*>(attribute_node); 2280 << 1715 if (!attribute) 2281 new G4Torus(name, rmin, rmax, rtor, startph << 1716 { 2282 } << 1717 G4Exception("G4GDMLReadSolids::GenTrapRead()", 2283 << 1718 "InvalidRead", FatalException, "No attribute found!"); 2284 // ------------------------------------------ << 1719 return; 2285 void G4GDMLReadSolids::GenTrapRead( << 1720 } 2286 const xercesc::DOMElement* const gtrapEleme << 1721 const G4String attName = Transcode(attribute->getName()); 2287 { << 1722 const G4String attValue = Transcode(attribute->getValue()); 2288 G4String name; << 1723 2289 G4double lunit = 1.0; << 1724 if (attName=="name") { name = GenerateName(attValue); } else 2290 G4double dz = 0.0; << 1725 if (attName=="lunit") { G4UnitDefinition::GetValueOf(attValue); 2291 G4double v1x = 0.0, v1y = 0.0, v2x = 0.0, v << 1726 if (G4UnitDefinition::GetCategory(attValue)!="Length") { 2292 v4x = 0.0, v4y = 0.0, v5x = 0.0, v << 1727 G4Exception("G4GDMLReadSolids::GenTrapRead()", "InvalidRead", 2293 v7x = 0.0, v7y = 0.0, v8x = 0.0, v << 1728 FatalException, "Invalid unit for length!"); } 2294 << 1729 } else 2295 const xercesc::DOMNamedNodeMap* const attri << 1730 if (attName=="dz") { dz = eval.Evaluate(attValue); } else 2296 gtrapElement->getAttributes(); << 1731 if (attName=="v1x") { v1x = eval.Evaluate(attValue); } else 2297 XMLSize_t attributeCount = attributes->getL << 1732 if (attName=="v1y") { v1y = eval.Evaluate(attValue); } else 2298 << 1733 if (attName=="v2x") { v2x = eval.Evaluate(attValue); } else 2299 for(XMLSize_t attribute_index = 0; attribut << 1734 if (attName=="v2y") { v2y = eval.Evaluate(attValue); } else 2300 ++attribute_index) << 1735 if (attName=="v3x") { v3x = eval.Evaluate(attValue); } else 2301 { << 1736 if (attName=="v3y") { v3y = eval.Evaluate(attValue); } else 2302 xercesc::DOMNode* attribute_node = attrib << 1737 if (attName=="v4x") { v4x = eval.Evaluate(attValue); } else 2303 << 1738 if (attName=="v4y") { v4y = eval.Evaluate(attValue); } else 2304 if(attribute_node->getNodeType() != xerce << 1739 if (attName=="v5x") { v5x = eval.Evaluate(attValue); } else 2305 { << 1740 if (attName=="v5y") { v5y = eval.Evaluate(attValue); } else 2306 continue; << 1741 if (attName=="v6x") { v6x = eval.Evaluate(attValue); } else 2307 } << 1742 if (attName=="v6y") { v6y = eval.Evaluate(attValue); } else 2308 << 1743 if (attName=="v7x") { v7x = eval.Evaluate(attValue); } else 2309 const xercesc::DOMAttr* const attribute = << 1744 if (attName=="v7y") { v7y = eval.Evaluate(attValue); } else 2310 dynamic_cast<xercesc::DOMAttr*>(attribu << 1745 if (attName=="v8x") { v8x = eval.Evaluate(attValue); } else 2311 if(attribute == nullptr) << 1746 if (attName=="v8y") { v8y = eval.Evaluate(attValue); } 2312 { << 1747 } 2313 G4Exception("G4GDMLReadSolids::GenTrapR << 1748 2314 FatalException, "No attribu << 1749 dz *= lunit; 2315 return; << 1750 std::vector<G4TwoVector> vertices; 2316 } << 1751 vertices.push_back(G4TwoVector(v1x*lunit,v1y*lunit)); 2317 const G4String attName = Transcode(attri << 1752 vertices.push_back(G4TwoVector(v2x*lunit,v2y*lunit)); 2318 const G4String attValue = Transcode(attri << 1753 vertices.push_back(G4TwoVector(v3x*lunit,v3y*lunit)); 2319 << 1754 vertices.push_back(G4TwoVector(v4x*lunit,v4y*lunit)); 2320 if(attName == "name") << 1755 vertices.push_back(G4TwoVector(v5x*lunit,v5y*lunit)); 2321 { << 1756 vertices.push_back(G4TwoVector(v6x*lunit,v6y*lunit)); 2322 name = GenerateName(attValue); << 1757 vertices.push_back(G4TwoVector(v7x*lunit,v7y*lunit)); 2323 } << 1758 vertices.push_back(G4TwoVector(v8x*lunit,v8y*lunit)); 2324 else if(attName == "lunit") << 1759 new G4GenericTrap(name,dz,vertices); 2325 { << 2326 lunit = G4UnitDefinition::GetValueOf(at << 2327 if(G4UnitDefinition::GetCategory(attVal << 2328 { << 2329 G4Exception("G4GDMLReadSolids::GenTra << 2330 FatalException, "Invalid << 2331 } << 2332 } << 2333 else if(attName == "dz") << 2334 { << 2335 dz = eval.Evaluate(attValue); << 2336 } << 2337 else if(attName == "v1x") << 2338 { << 2339 v1x = eval.Evaluate(attValue); << 2340 } << 2341 else if(attName == "v1y") << 2342 { << 2343 v1y = eval.Evaluate(attValue); << 2344 } << 2345 else if(attName == "v2x") << 2346 { << 2347 v2x = eval.Evaluate(attValue); << 2348 } << 2349 else if(attName == "v2y") << 2350 { << 2351 v2y = eval.Evaluate(attValue); << 2352 } << 2353 else if(attName == "v3x") << 2354 { << 2355 v3x = eval.Evaluate(attValue); << 2356 } << 2357 else if(attName == "v3y") << 2358 { << 2359 v3y = eval.Evaluate(attValue); << 2360 } << 2361 else if(attName == "v4x") << 2362 { << 2363 v4x = eval.Evaluate(attValue); << 2364 } << 2365 else if(attName == "v4y") << 2366 { << 2367 v4y = eval.Evaluate(attValue); << 2368 } << 2369 else if(attName == "v5x") << 2370 { << 2371 v5x = eval.Evaluate(attValue); << 2372 } << 2373 else if(attName == "v5y") << 2374 { << 2375 v5y = eval.Evaluate(attValue); << 2376 } << 2377 else if(attName == "v6x") << 2378 { << 2379 v6x = eval.Evaluate(attValue); << 2380 } << 2381 else if(attName == "v6y") << 2382 { << 2383 v6y = eval.Evaluate(attValue); << 2384 } << 2385 else if(attName == "v7x") << 2386 { << 2387 v7x = eval.Evaluate(attValue); << 2388 } << 2389 else if(attName == "v7y") << 2390 { << 2391 v7y = eval.Evaluate(attValue); << 2392 } << 2393 else if(attName == "v8x") << 2394 { << 2395 v8x = eval.Evaluate(attValue); << 2396 } << 2397 else if(attName == "v8y") << 2398 { << 2399 v8y = eval.Evaluate(attValue); << 2400 } << 2401 } << 2402 << 2403 dz *= lunit; << 2404 std::vector<G4TwoVector> vertices; << 2405 vertices.push_back(G4TwoVector(v1x * lunit, << 2406 vertices.push_back(G4TwoVector(v2x * lunit, << 2407 vertices.push_back(G4TwoVector(v3x * lunit, << 2408 vertices.push_back(G4TwoVector(v4x * lunit, << 2409 vertices.push_back(G4TwoVector(v5x * lunit, << 2410 vertices.push_back(G4TwoVector(v6x * lunit, << 2411 vertices.push_back(G4TwoVector(v7x * lunit, << 2412 vertices.push_back(G4TwoVector(v8x * lunit, << 2413 new G4GenericTrap(name, dz, vertices); << 2414 } 1760 } 2415 1761 2416 // ------------------------------------------ << 2417 void G4GDMLReadSolids::TrapRead(const xercesc 1762 void G4GDMLReadSolids::TrapRead(const xercesc::DOMElement* const trapElement) 2418 { 1763 { 2419 G4String name; << 1764 G4String name; 2420 G4double lunit = 1.0; << 1765 G4double lunit = 1.0; 2421 G4double aunit = 1.0; << 1766 G4double aunit = 1.0; 2422 G4double z = 0.0; << 1767 G4double z = 0.0; 2423 G4double theta = 0.0; << 1768 G4double theta = 0.0; 2424 G4double phi = 0.0; << 1769 G4double phi = 0.0; 2425 G4double y1 = 0.0; << 1770 G4double y1 = 0.0; 2426 G4double x1 = 0.0; << 1771 G4double x1 = 0.0; 2427 G4double x2 = 0.0; << 1772 G4double x2 = 0.0; 2428 G4double alpha1 = 0.0; << 1773 G4double alpha1 = 0.0; 2429 G4double y2 = 0.0; << 1774 G4double y2 = 0.0; 2430 G4double x3 = 0.0; << 1775 G4double x3 = 0.0; 2431 G4double x4 = 0.0; << 1776 G4double x4 = 0.0; 2432 G4double alpha2 = 0.0; << 1777 G4double alpha2 = 0.0; 2433 << 1778 2434 const xercesc::DOMNamedNodeMap* const attri << 1779 const xercesc::DOMNamedNodeMap* const attributes 2435 trapElement->getAttributes(); << 1780 = trapElement->getAttributes(); 2436 XMLSize_t attributeCount = attributes->getL << 1781 XMLSize_t attributeCount = attributes->getLength(); 2437 << 1782 2438 for(XMLSize_t attribute_index = 0; attribut << 1783 for (XMLSize_t attribute_index=0; 2439 ++attribute_index) << 1784 attribute_index<attributeCount; attribute_index++) 2440 { << 1785 { 2441 xercesc::DOMNode* attribute_node = attrib << 1786 xercesc::DOMNode* attribute_node = attributes->item(attribute_index); 2442 << 1787 2443 if(attribute_node->getNodeType() != xerce << 1788 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE) 2444 { << 1789 { continue; } 2445 continue; << 1790 2446 } << 1791 const xercesc::DOMAttr* const attribute 2447 << 1792 = dynamic_cast<xercesc::DOMAttr*>(attribute_node); 2448 const xercesc::DOMAttr* const attribute = << 1793 if (!attribute) 2449 dynamic_cast<xercesc::DOMAttr*>(attribu << 1794 { 2450 if(attribute == nullptr) << 1795 G4Exception("G4GDMLReadSolids::TrapRead()", 2451 { << 1796 "InvalidRead", FatalException, "No attribute found!"); 2452 G4Exception("G4GDMLReadSolids::TrapRead << 1797 return; 2453 "No attribute found!"); << 1798 } 2454 return; << 1799 const G4String attName = Transcode(attribute->getName()); 2455 } << 1800 const G4String attValue = Transcode(attribute->getValue()); 2456 const G4String attName = Transcode(attri << 1801 2457 const G4String attValue = Transcode(attri << 1802 if (attName=="name") { name = GenerateName(attValue); } else 2458 << 1803 if (attName=="lunit") { lunit = G4UnitDefinition::GetValueOf(attValue); 2459 if(attName == "name") << 1804 if (G4UnitDefinition::GetCategory(attValue)!="Length") { 2460 { << 1805 G4Exception("G4GDMLReadSolids::TrapRead()", "InvalidRead", 2461 name = GenerateName(attValue); << 1806 FatalException, "Invalid unit for length!"); } 2462 } << 1807 } else 2463 else if(attName == "lunit") << 1808 if (attName=="aunit") { aunit = G4UnitDefinition::GetValueOf(attValue); 2464 { << 1809 if (G4UnitDefinition::GetCategory(attValue)!="Angle") { 2465 lunit = G4UnitDefinition::GetValueOf(at << 1810 G4Exception("G4GDMLReadSolids::TrapRead()", "InvalidRead", 2466 if(G4UnitDefinition::GetCategory(attVal << 1811 FatalException, "Invalid unit for angle!"); } 2467 { << 1812 } else 2468 G4Exception("G4GDMLReadSolids::TrapRe << 1813 if (attName=="z") { z = eval.Evaluate(attValue); } else 2469 FatalException, "Invalid << 1814 if (attName=="theta") { theta = eval.Evaluate(attValue); } else 2470 } << 1815 if (attName=="phi") { phi = eval.Evaluate(attValue); } else 2471 } << 1816 if (attName=="y1") { y1 = eval.Evaluate(attValue); } else 2472 else if(attName == "aunit") << 1817 if (attName=="x1") { x1 = eval.Evaluate(attValue); } else 2473 { << 1818 if (attName=="x2") { x2 = eval.Evaluate(attValue); } else 2474 aunit = G4UnitDefinition::GetValueOf(at << 1819 if (attName=="alpha1") { alpha1 = eval.Evaluate(attValue); } else 2475 if(G4UnitDefinition::GetCategory(attVal << 1820 if (attName=="y2") { y2 = eval.Evaluate(attValue); } else 2476 { << 1821 if (attName=="x3") { x3 = eval.Evaluate(attValue); } else 2477 G4Exception("G4GDMLReadSolids::TrapRe << 1822 if (attName=="x4") { x4 = eval.Evaluate(attValue); } else 2478 FatalException, "Invalid << 1823 if (attName=="alpha2") { alpha2 = eval.Evaluate(attValue); } 2479 } << 1824 } 2480 } << 1825 2481 else if(attName == "z") << 1826 z *= 0.5*lunit; 2482 { << 1827 theta *= aunit; 2483 z = eval.Evaluate(attValue); << 1828 phi *= aunit; 2484 } << 1829 y1 *= 0.5*lunit; 2485 else if(attName == "theta") << 1830 x1 *= 0.5*lunit; 2486 { << 1831 x2 *= 0.5*lunit; 2487 theta = eval.Evaluate(attValue); << 1832 alpha1 *= aunit; 2488 } << 1833 y2 *= 0.5*lunit; 2489 else if(attName == "phi") << 1834 x3 *= 0.5*lunit; 2490 { << 1835 x4 *= 0.5*lunit; 2491 phi = eval.Evaluate(attValue); << 1836 alpha2 *= aunit; 2492 } << 2493 else if(attName == "y1") << 2494 { << 2495 y1 = eval.Evaluate(attValue); << 2496 } << 2497 else if(attName == "x1") << 2498 { << 2499 x1 = eval.Evaluate(attValue); << 2500 } << 2501 else if(attName == "x2") << 2502 { << 2503 x2 = eval.Evaluate(attValue); << 2504 } << 2505 else if(attName == "alpha1") << 2506 { << 2507 alpha1 = eval.Evaluate(attValue); << 2508 } << 2509 else if(attName == "y2") << 2510 { << 2511 y2 = eval.Evaluate(attValue); << 2512 } << 2513 else if(attName == "x3") << 2514 { << 2515 x3 = eval.Evaluate(attValue); << 2516 } << 2517 else if(attName == "x4") << 2518 { << 2519 x4 = eval.Evaluate(attValue); << 2520 } << 2521 else if(attName == "alpha2") << 2522 { << 2523 alpha2 = eval.Evaluate(attValue); << 2524 } << 2525 } << 2526 << 2527 z *= 0.5 * lunit; << 2528 theta *= aunit; << 2529 phi *= aunit; << 2530 y1 *= 0.5 * lunit; << 2531 x1 *= 0.5 * lunit; << 2532 x2 *= 0.5 * lunit; << 2533 alpha1 *= aunit; << 2534 y2 *= 0.5 * lunit; << 2535 x3 *= 0.5 * lunit; << 2536 x4 *= 0.5 * lunit; << 2537 alpha2 *= aunit; << 2538 1837 2539 new G4Trap(name, z, theta, phi, y1, x1, x2, << 1838 new G4Trap(name,z,theta,phi,y1,x1,x2,alpha1,y2,x3,x4,alpha2); 2540 } 1839 } 2541 1840 2542 // ------------------------------------------ << 2543 void G4GDMLReadSolids::TrdRead(const xercesc: 1841 void G4GDMLReadSolids::TrdRead(const xercesc::DOMElement* const trdElement) 2544 { 1842 { 2545 G4String name; << 1843 G4String name; 2546 G4double lunit = 1.0; << 1844 G4double lunit = 1.0; 2547 G4double x1 = 0.0; << 1845 G4double x1 = 0.0; 2548 G4double x2 = 0.0; << 1846 G4double x2 = 0.0; 2549 G4double y1 = 0.0; << 1847 G4double y1 = 0.0; 2550 G4double y2 = 0.0; << 1848 G4double y2 = 0.0; 2551 G4double z = 0.0; << 1849 G4double z = 0.0; 2552 << 1850 2553 const xercesc::DOMNamedNodeMap* const attri << 1851 const xercesc::DOMNamedNodeMap* const attributes = trdElement->getAttributes(); 2554 trdElement->getAttributes(); << 1852 XMLSize_t attributeCount = attributes->getLength(); 2555 XMLSize_t attributeCount = attributes->getL << 1853 2556 << 1854 for (XMLSize_t attribute_index=0; 2557 for(XMLSize_t attribute_index = 0; attribut << 1855 attribute_index<attributeCount; attribute_index++) 2558 ++attribute_index) << 1856 { 2559 { << 1857 xercesc::DOMNode* attribute_node = attributes->item(attribute_index); 2560 xercesc::DOMNode* attribute_node = attrib << 1858 2561 << 1859 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE) 2562 if(attribute_node->getNodeType() != xerce << 1860 { continue; } 2563 { << 1861 2564 continue; << 1862 const xercesc::DOMAttr* const attribute 2565 } << 1863 = dynamic_cast<xercesc::DOMAttr*>(attribute_node); 2566 << 1864 if (!attribute) 2567 const xercesc::DOMAttr* const attribute = << 1865 { 2568 dynamic_cast<xercesc::DOMAttr*>(attribu << 1866 G4Exception("G4GDMLReadSolids::TrdRead()", 2569 if(attribute == nullptr) << 1867 "InvalidRead", FatalException, "No attribute found!"); 2570 { << 1868 return; 2571 G4Exception("G4GDMLReadSolids::TrdRead( << 1869 } 2572 "No attribute found!"); << 1870 const G4String attName = Transcode(attribute->getName()); 2573 return; << 1871 const G4String attValue = Transcode(attribute->getValue()); 2574 } << 1872 2575 const G4String attName = Transcode(attri << 1873 if (attName=="name") { name = GenerateName(attValue); } else 2576 const G4String attValue = Transcode(attri << 1874 if (attName=="lunit") { lunit = G4UnitDefinition::GetValueOf(attValue); 2577 << 1875 if (G4UnitDefinition::GetCategory(attValue)!="Length") { 2578 if(attName == "name") << 1876 G4Exception("G4GDMLReadSolids::TrdRead()", "InvalidRead", 2579 { << 1877 FatalException, "Invalid unit for length!"); } 2580 name = GenerateName(attValue); << 1878 } else 2581 } << 1879 if (attName=="x1") { x1 = eval.Evaluate(attValue); } else 2582 else if(attName == "lunit") << 1880 if (attName=="x2") { x2 = eval.Evaluate(attValue); } else 2583 { << 1881 if (attName=="y1") { y1 = eval.Evaluate(attValue); } else 2584 lunit = G4UnitDefinition::GetValueOf(at << 1882 if (attName=="y2") { y2 = eval.Evaluate(attValue); } else 2585 if(G4UnitDefinition::GetCategory(attVal << 1883 if (attName=="z") { z = eval.Evaluate(attValue); } 2586 { << 1884 } 2587 G4Exception("G4GDMLReadSolids::TrdRea << 1885 2588 FatalException, "Invalid << 1886 x1 *= 0.5*lunit; 2589 } << 1887 x2 *= 0.5*lunit; 2590 } << 1888 y1 *= 0.5*lunit; 2591 else if(attName == "x1") << 1889 y2 *= 0.5*lunit; 2592 { << 1890 z *= 0.5*lunit; 2593 x1 = eval.Evaluate(attValue); << 1891 2594 } << 1892 new G4Trd(name,x1,x2,y1,y2,z); 2595 else if(attName == "x2") << 1893 } 2596 { << 1894 2597 x2 = eval.Evaluate(attValue); << 1895 G4TriangularFacet* G4GDMLReadSolids:: 2598 } << 1896 TriangularRead(const xercesc::DOMElement* const triangularElement) 2599 else if(attName == "y1") << 1897 { 2600 { << 1898 G4ThreeVector vertex1; 2601 y1 = eval.Evaluate(attValue); << 1899 G4ThreeVector vertex2; 2602 } << 1900 G4ThreeVector vertex3; 2603 else if(attName == "y2") << 1901 G4FacetVertexType type = ABSOLUTE; 2604 { << 1902 G4double lunit = 1.0; 2605 y2 = eval.Evaluate(attValue); << 1903 2606 } << 1904 const xercesc::DOMNamedNodeMap* const attributes 2607 else if(attName == "z") << 1905 = triangularElement->getAttributes(); 2608 { << 1906 XMLSize_t attributeCount = attributes->getLength(); 2609 z = eval.Evaluate(attValue); << 1907 2610 } << 1908 for (XMLSize_t attribute_index=0; 2611 } << 1909 attribute_index<attributeCount; attribute_index++) 2612 << 1910 { 2613 x1 *= 0.5 * lunit; << 1911 xercesc::DOMNode* attribute_node = attributes->item(attribute_index); 2614 x2 *= 0.5 * lunit; << 1912 2615 y1 *= 0.5 * lunit; << 1913 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE) 2616 y2 *= 0.5 * lunit; << 1914 { continue; } 2617 z *= 0.5 * lunit; << 1915 >> 1916 const xercesc::DOMAttr* const attribute >> 1917 = dynamic_cast<xercesc::DOMAttr*>(attribute_node); >> 1918 if (!attribute) >> 1919 { >> 1920 G4Exception("G4GDMLReadSolids::TriangularRead()", >> 1921 "InvalidRead", FatalException, "No attribute found!"); >> 1922 return 0; >> 1923 } >> 1924 const G4String attName = Transcode(attribute->getName()); >> 1925 const G4String attValue = Transcode(attribute->getValue()); >> 1926 >> 1927 if (attName=="vertex1") >> 1928 { vertex1 = GetPosition(GenerateName(attValue)); } else >> 1929 if (attName=="vertex2") >> 1930 { vertex2 = GetPosition(GenerateName(attValue)); } else >> 1931 if (attName=="vertex3") >> 1932 { vertex3 = GetPosition(GenerateName(attValue)); } else >> 1933 if (attName=="lunit") >> 1934 { lunit = G4UnitDefinition::GetValueOf(attValue); >> 1935 if (G4UnitDefinition::GetCategory(attValue)!="Length") { >> 1936 G4Exception("G4GDMLReadSolids::TriangularRead()", "InvalidRead", >> 1937 FatalException, "Invalid unit for length!"); } >> 1938 } else >> 1939 if (attName=="type") >> 1940 { if (attValue=="RELATIVE") { type = RELATIVE; } } >> 1941 } 2618 1942 2619 new G4Trd(name, x1, x2, y1, y2, z); << 1943 return new G4TriangularFacet(vertex1*lunit,vertex2*lunit,vertex3*lunit,type); 2620 } 1944 } 2621 1945 2622 // ------------------------------------------ << 2623 G4TriangularFacet* G4GDMLReadSolids::Triangul << 2624 const xercesc::DOMElement* const triangular << 2625 { << 2626 G4ThreeVector vertex1; << 2627 G4ThreeVector vertex2; << 2628 G4ThreeVector vertex3; << 2629 G4FacetVertexType type = ABSOLUTE; << 2630 G4double lunit = 1.0; << 2631 << 2632 const xercesc::DOMNamedNodeMap* const attri << 2633 triangularElement->getAttributes(); << 2634 XMLSize_t attributeCount = attributes->getL << 2635 << 2636 for(XMLSize_t attribute_index = 0; attribut << 2637 ++attribute_index) << 2638 { << 2639 xercesc::DOMNode* attribute_node = attrib << 2640 << 2641 if(attribute_node->getNodeType() != xerce << 2642 { << 2643 continue; << 2644 } << 2645 << 2646 const xercesc::DOMAttr* const attribute = << 2647 dynamic_cast<xercesc::DOMAttr*>(attribu << 2648 if(attribute == nullptr) << 2649 { << 2650 G4Exception("G4GDMLReadSolids::Triangul << 2651 FatalException, "No attribu << 2652 return nullptr; << 2653 } << 2654 const G4String attName = Transcode(attri << 2655 const G4String attValue = Transcode(attri << 2656 << 2657 if(attName == "vertex1") << 2658 { << 2659 vertex1 = GetPosition(GenerateName(attV << 2660 } << 2661 else if(attName == "vertex2") << 2662 { << 2663 vertex2 = GetPosition(GenerateName(attV << 2664 } << 2665 else if(attName == "vertex3") << 2666 { << 2667 vertex3 = GetPosition(GenerateName(attV << 2668 } << 2669 else if(attName == "lunit") << 2670 { << 2671 lunit = G4UnitDefinition::GetValueOf(at << 2672 if(G4UnitDefinition::GetCategory(attVal << 2673 { << 2674 G4Exception("G4GDMLReadSolids::Triang << 2675 FatalException, "Invalid << 2676 } << 2677 } << 2678 else if(attName == "type") << 2679 { << 2680 if(attValue == "RELATIVE") << 2681 { << 2682 type = RELATIVE; << 2683 } << 2684 } << 2685 } << 2686 << 2687 return new G4TriangularFacet(vertex1 * luni << 2688 vertex3 * luni << 2689 } << 2690 << 2691 // ------------------------------------------ << 2692 void G4GDMLReadSolids::TubeRead(const xercesc 1946 void G4GDMLReadSolids::TubeRead(const xercesc::DOMElement* const tubeElement) 2693 { 1947 { 2694 G4String name; << 1948 G4String name; 2695 G4double lunit = 1.0; << 1949 G4double lunit = 1.0; 2696 G4double aunit = 1.0; << 1950 G4double aunit = 1.0; 2697 G4double rmin = 0.0; << 1951 G4double rmin = 0.0; 2698 G4double rmax = 0.0; << 1952 G4double rmax = 0.0; 2699 G4double z = 0.0; << 1953 G4double z = 0.0; 2700 G4double startphi = 0.0; << 1954 G4double startphi = 0.0; 2701 G4double deltaphi = 0.0; << 1955 G4double deltaphi = 0.0; 2702 << 1956 2703 const xercesc::DOMNamedNodeMap* const attri << 1957 const xercesc::DOMNamedNodeMap* const attributes 2704 tubeElement->getAttributes(); << 1958 = tubeElement->getAttributes(); 2705 XMLSize_t attributeCount = attributes->getL << 1959 XMLSize_t attributeCount = attributes->getLength(); 2706 << 1960 2707 for(XMLSize_t attribute_index = 0; attribut << 1961 for (XMLSize_t attribute_index=0; 2708 ++attribute_index) << 1962 attribute_index<attributeCount; attribute_index++) 2709 { << 1963 { 2710 xercesc::DOMNode* attribute_node = attrib << 1964 xercesc::DOMNode* attribute_node = attributes->item(attribute_index); 2711 << 1965 2712 if(attribute_node->getNodeType() != xerce << 1966 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE) 2713 { << 1967 { continue; } 2714 continue; << 1968 2715 } << 1969 const xercesc::DOMAttr* const attribute 2716 << 1970 = dynamic_cast<xercesc::DOMAttr*>(attribute_node); 2717 const xercesc::DOMAttr* const attribute = << 1971 if (!attribute) 2718 dynamic_cast<xercesc::DOMAttr*>(attribu << 1972 { 2719 if(attribute == nullptr) << 1973 G4Exception("G4GDMLReadSolids::TubeRead()", 2720 { << 1974 "InvalidRead", FatalException, "No attribute found!"); 2721 G4Exception("G4GDMLReadSolids::TubeRead << 1975 return; 2722 "No attribute found!"); << 1976 } 2723 return; << 1977 const G4String attName = Transcode(attribute->getName()); 2724 } << 1978 const G4String attValue = Transcode(attribute->getValue()); 2725 const G4String attName = Transcode(attri << 1979 2726 const G4String attValue = Transcode(attri << 1980 if (attName=="name") { name = GenerateName(attValue); } else 2727 << 1981 if (attName=="lunit") { lunit = G4UnitDefinition::GetValueOf(attValue); 2728 if(attName == "name") << 1982 if (G4UnitDefinition::GetCategory(attValue)!="Length") { 2729 { << 1983 G4Exception("G4GDMLReadSolids::TubeRead()", "InvalidRead", 2730 name = GenerateName(attValue); << 1984 FatalException, "Invalid unit for length!"); } 2731 } << 1985 } else 2732 else if(attName == "lunit") << 1986 if (attName=="aunit") { aunit = G4UnitDefinition::GetValueOf(attValue); 2733 { << 1987 if (G4UnitDefinition::GetCategory(attValue)!="Angle") { 2734 lunit = G4UnitDefinition::GetValueOf(at << 1988 G4Exception("G4GDMLReadSolids::TubeRead()", "InvalidRead", 2735 if(G4UnitDefinition::GetCategory(attVal << 1989 FatalException, "Invalid unit for angle!"); } 2736 { << 1990 } else 2737 G4Exception("G4GDMLReadSolids::TubeRe << 1991 if (attName=="rmin") { rmin = eval.Evaluate(attValue); } else 2738 FatalException, "Invalid << 1992 if (attName=="rmax") { rmax = eval.Evaluate(attValue); } else 2739 } << 1993 if (attName=="z") { z = eval.Evaluate(attValue); } else 2740 } << 1994 if (attName=="startphi") { startphi = eval.Evaluate(attValue); } else 2741 else if(attName == "aunit") << 1995 if (attName=="deltaphi") { deltaphi = eval.Evaluate(attValue); } 2742 { << 1996 } 2743 aunit = G4UnitDefinition::GetValueOf(at << 1997 2744 if(G4UnitDefinition::GetCategory(attVal << 1998 rmin *= lunit; 2745 { << 1999 rmax *= lunit; 2746 G4Exception("G4GDMLReadSolids::TubeRe << 2000 z *= 0.5*lunit; 2747 FatalException, "Invalid << 2001 startphi *= aunit; 2748 } << 2002 deltaphi *= aunit; 2749 } << 2003 2750 else if(attName == "rmin") << 2004 new G4Tubs(name,rmin,rmax,z,startphi,deltaphi); 2751 { << 2005 } 2752 rmin = eval.Evaluate(attValue); << 2006 2753 } << 2007 void G4GDMLReadSolids::CutTubeRead(const xercesc::DOMElement* const cuttubeElement) 2754 else if(attName == "rmax") << 2008 { 2755 { << 2009 G4String name; 2756 rmax = eval.Evaluate(attValue); << 2010 G4double lunit = 1.0; 2757 } << 2011 G4double aunit = 1.0; 2758 else if(attName == "z") << 2012 G4double rmin = 0.0; 2759 { << 2013 G4double rmax = 0.0; 2760 z = eval.Evaluate(attValue); << 2014 G4double z = 0.0; 2761 } << 2015 G4double startphi = 0.0; 2762 else if(attName == "startphi") << 2016 G4double deltaphi = 0.0; 2763 { << 2017 G4ThreeVector lowNorm(0); 2764 startphi = eval.Evaluate(attValue); << 2018 G4ThreeVector highNorm(0); 2765 } << 2019 2766 else if(attName == "deltaphi") << 2020 const xercesc::DOMNamedNodeMap* const attributes 2767 { << 2021 = cuttubeElement->getAttributes(); 2768 deltaphi = eval.Evaluate(attValue); << 2022 XMLSize_t attributeCount = attributes->getLength(); 2769 } << 2023 2770 } << 2024 for (XMLSize_t attribute_index=0; 2771 << 2025 attribute_index<attributeCount; attribute_index++) 2772 rmin *= lunit; << 2026 { 2773 rmax *= lunit; << 2027 xercesc::DOMNode* attribute_node = attributes->item(attribute_index); 2774 z *= 0.5 * lunit; << 2028 2775 startphi *= aunit; << 2029 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE) 2776 deltaphi *= aunit; << 2030 { continue; } 2777 << 2031 2778 new G4Tubs(name, rmin, rmax, z, startphi, d << 2032 const xercesc::DOMAttr* const attribute 2779 } << 2033 = dynamic_cast<xercesc::DOMAttr*>(attribute_node); 2780 << 2034 if (!attribute) 2781 // ------------------------------------------ << 2035 { 2782 void G4GDMLReadSolids::CutTubeRead( << 2036 G4Exception("G4GDMLReadSolids::CutTubeRead()", 2783 const xercesc::DOMElement* const cuttubeEle << 2037 "InvalidRead", FatalException, "No attribute found!"); 2784 { << 2038 return; 2785 G4String name; << 2039 } 2786 G4double lunit = 1.0; << 2040 const G4String attName = Transcode(attribute->getName()); 2787 G4double aunit = 1.0; << 2041 const G4String attValue = Transcode(attribute->getValue()); 2788 G4double rmin = 0.0; << 2042 2789 G4double rmax = 0.0; << 2043 if (attName=="name") { name = GenerateName(attValue); } else 2790 G4double z = 0.0; << 2044 if (attName=="lunit") { lunit = G4UnitDefinition::GetValueOf(attValue); 2791 G4double startphi = 0.0; << 2045 if (G4UnitDefinition::GetCategory(attValue)!="Length") { 2792 G4double deltaphi = 0.0; << 2046 G4Exception("G4GDMLReadSolids::CutTubeRead()", "InvalidRead", 2793 G4ThreeVector lowNorm(0); << 2047 FatalException, "Invalid unit for length!"); } 2794 G4ThreeVector highNorm(0); << 2048 } else 2795 << 2049 if (attName=="aunit") { aunit = G4UnitDefinition::GetValueOf(attValue); 2796 const xercesc::DOMNamedNodeMap* const attri << 2050 if (G4UnitDefinition::GetCategory(attValue)!="Angle") { 2797 cuttubeElement->getAttributes(); << 2051 G4Exception("G4GDMLReadSolids::CutTubeRead()", "InvalidRead", 2798 XMLSize_t attributeCount = attributes->getL << 2052 FatalException, "Invalid unit for angle!"); } 2799 << 2053 } else 2800 for(XMLSize_t attribute_index = 0; attribut << 2054 if (attName=="rmin") { rmin = eval.Evaluate(attValue); } else 2801 ++attribute_index) << 2055 if (attName=="rmax") { rmax = eval.Evaluate(attValue); } else 2802 { << 2056 if (attName=="z") { z = eval.Evaluate(attValue); } else 2803 xercesc::DOMNode* attribute_node = attrib << 2057 if (attName=="startphi") { startphi = eval.Evaluate(attValue); } else 2804 << 2058 if (attName=="deltaphi") { deltaphi = eval.Evaluate(attValue); } else 2805 if(attribute_node->getNodeType() != xerce << 2059 if (attName=="lowX") { lowNorm.setX (eval.Evaluate(attValue)); } else 2806 { << 2060 if (attName=="lowY") { lowNorm.setY (eval.Evaluate(attValue)); } else 2807 continue; << 2061 if (attName=="lowZ") { lowNorm.setZ (eval.Evaluate(attValue)); } else 2808 } << 2062 if (attName=="highX") { highNorm.setX (eval.Evaluate(attValue)); } else 2809 << 2063 if (attName=="highY") { highNorm.setY (eval.Evaluate(attValue)); } else 2810 const xercesc::DOMAttr* const attribute = << 2064 if (attName=="highZ") { highNorm.setZ (eval.Evaluate(attValue)); } 2811 dynamic_cast<xercesc::DOMAttr*>(attribu << 2065 2812 if(attribute == nullptr) << 2066 } 2813 { << 2067 2814 G4Exception("G4GDMLReadSolids::CutTubeR << 2068 rmin *= lunit; 2815 FatalException, "No attribu << 2069 rmax *= lunit; 2816 return; << 2070 z *= 0.5*lunit; 2817 } << 2071 startphi *= aunit; 2818 const G4String attName = Transcode(attri << 2072 deltaphi *= aunit; 2819 const G4String attValue = Transcode(attri << 2073 2820 << 2074 new G4CutTubs(name,rmin,rmax,z,startphi,deltaphi,lowNorm,highNorm); 2821 if(attName == "name") << 2075 } 2822 { << 2076 2823 name = GenerateName(attValue); << 2077 void G4GDMLReadSolids:: 2824 } << 2078 TwistedboxRead(const xercesc::DOMElement* const twistedboxElement) 2825 else if(attName == "lunit") << 2079 { 2826 { << 2080 G4String name; 2827 lunit = G4UnitDefinition::GetValueOf(at << 2081 G4double lunit = 1.0; 2828 if(G4UnitDefinition::GetCategory(attVal << 2082 G4double aunit = 1.0; 2829 { << 2083 G4double PhiTwist = 0.0; 2830 G4Exception("G4GDMLReadSolids::CutTub << 2084 G4double x = 0.0; 2831 FatalException, "Invalid << 2085 G4double y = 0.0; 2832 } << 2086 G4double z = 0.0; 2833 } << 2087 2834 else if(attName == "aunit") << 2088 const xercesc::DOMNamedNodeMap* const attributes 2835 { << 2089 = twistedboxElement->getAttributes(); 2836 aunit = G4UnitDefinition::GetValueOf(at << 2090 XMLSize_t attributeCount = attributes->getLength(); 2837 if(G4UnitDefinition::GetCategory(attVal << 2091 2838 { << 2092 for (XMLSize_t attribute_index=0; 2839 G4Exception("G4GDMLReadSolids::CutTub << 2093 attribute_index<attributeCount; attribute_index++) 2840 FatalException, "Invalid << 2094 { 2841 } << 2095 xercesc::DOMNode* attribute_node = attributes->item(attribute_index); 2842 } << 2096 2843 else if(attName == "rmin") << 2097 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE) 2844 { << 2098 { continue; } 2845 rmin = eval.Evaluate(attValue); << 2099 2846 } << 2100 const xercesc::DOMAttr* const attribute 2847 else if(attName == "rmax") << 2101 = dynamic_cast<xercesc::DOMAttr*>(attribute_node); 2848 { << 2102 if (!attribute) 2849 rmax = eval.Evaluate(attValue); << 2103 { 2850 } << 2104 G4Exception("G4GDMLReadSolids::TwistedboxRead()", 2851 else if(attName == "z") << 2105 "InvalidRead", FatalException, "No attribute found!"); 2852 { << 2106 return; 2853 z = eval.Evaluate(attValue); << 2107 } 2854 } << 2108 const G4String attName = Transcode(attribute->getName()); 2855 else if(attName == "startphi") << 2109 const G4String attValue = Transcode(attribute->getValue()); 2856 { << 2110 2857 startphi = eval.Evaluate(attValue); << 2111 if (attName=="name") { name = GenerateName(attValue); } else 2858 } << 2112 if (attName=="lunit") { lunit = G4UnitDefinition::GetValueOf(attValue); 2859 else if(attName == "deltaphi") << 2113 if (G4UnitDefinition::GetCategory(attValue)!="Length") { 2860 { << 2114 G4Exception("G4GDMLReadSolids::TwistedBoxRead()", "InvalidRead", 2861 deltaphi = eval.Evaluate(attValue); << 2115 FatalException, "Invalid unit for length!"); } 2862 } << 2116 } else 2863 else if(attName == "lowX") << 2117 if (attName=="aunit") { aunit = G4UnitDefinition::GetValueOf(attValue); 2864 { << 2118 if (G4UnitDefinition::GetCategory(attValue)!="Angle") { 2865 lowNorm.setX(eval.Evaluate(attValue)); << 2119 G4Exception("G4GDMLReadSolids::TwistedboxRead()", "InvalidRead", 2866 } << 2120 FatalException, "Invalid unit for angle!"); } 2867 else if(attName == "lowY") << 2121 } else 2868 { << 2122 if (attName=="PhiTwist") { PhiTwist = eval.Evaluate(attValue); } else 2869 lowNorm.setY(eval.Evaluate(attValue)); << 2123 if (attName=="x") { x = eval.Evaluate(attValue); } else 2870 } << 2124 if (attName=="y") { y = eval.Evaluate(attValue); } else 2871 else if(attName == "lowZ") << 2125 if (attName=="z") { z = eval.Evaluate(attValue); } 2872 { << 2126 } 2873 lowNorm.setZ(eval.Evaluate(attValue)); << 2127 2874 } << 2128 PhiTwist *= aunit; 2875 else if(attName == "highX") << 2129 x *= 0.5*lunit; 2876 { << 2130 y *= 0.5*lunit; 2877 highNorm.setX(eval.Evaluate(attValue)); << 2131 z *= 0.5*lunit; 2878 } << 2132 2879 else if(attName == "highY") << 2133 new G4TwistedBox(name,PhiTwist,x,y,z); 2880 { << 2134 } 2881 highNorm.setY(eval.Evaluate(attValue)); << 2135 2882 } << 2136 void G4GDMLReadSolids:: 2883 else if(attName == "highZ") << 2137 TwistedtrapRead(const xercesc::DOMElement* const twistedtrapElement) 2884 { << 2138 { 2885 highNorm.setZ(eval.Evaluate(attValue)); << 2139 G4String name; 2886 } << 2140 G4double lunit = 1.0; 2887 } << 2141 G4double aunit = 1.0; 2888 << 2142 G4double PhiTwist = 0.0; 2889 rmin *= lunit; << 2143 G4double z = 0.0; 2890 rmax *= lunit; << 2144 G4double Theta = 0.0; 2891 z *= 0.5 * lunit; << 2145 G4double Phi = 0.0; 2892 startphi *= aunit; << 2146 G4double y1 = 0.0; 2893 deltaphi *= aunit; << 2147 G4double x1 = 0.0; 2894 << 2148 G4double x2 = 0.0; 2895 new G4CutTubs(name, rmin, rmax, z, startphi << 2149 G4double y2 = 0.0; 2896 } << 2150 G4double x3 = 0.0; 2897 << 2151 G4double x4 = 0.0; 2898 // ------------------------------------------ << 2152 G4double Alph = 0.0; 2899 void G4GDMLReadSolids::TwistedboxRead( << 2153 2900 const xercesc::DOMElement* const twistedbox << 2154 const xercesc::DOMNamedNodeMap* const attributes 2901 { << 2155 = twistedtrapElement->getAttributes(); 2902 G4String name; << 2156 XMLSize_t attributeCount = attributes->getLength(); 2903 G4double lunit = 1.0; << 2157 2904 G4double aunit = 1.0; << 2158 for (XMLSize_t attribute_index=0; 2905 G4double PhiTwist = 0.0; << 2159 attribute_index<attributeCount; attribute_index++) 2906 G4double x = 0.0; << 2160 { 2907 G4double y = 0.0; << 2161 xercesc::DOMNode* attribute_node = attributes->item(attribute_index); 2908 G4double z = 0.0; << 2162 2909 << 2163 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE) 2910 const xercesc::DOMNamedNodeMap* const attri << 2164 { continue; } 2911 twistedboxElement->getAttributes(); << 2165 2912 XMLSize_t attributeCount = attributes->getL << 2166 const xercesc::DOMAttr* const attribute 2913 << 2167 = dynamic_cast<xercesc::DOMAttr*>(attribute_node); 2914 for(XMLSize_t attribute_index = 0; attribut << 2168 if (!attribute) 2915 ++attribute_index) << 2169 { 2916 { << 2170 G4Exception("G4GDMLReadSolids::TwistedtrapRead()", 2917 xercesc::DOMNode* attribute_node = attrib << 2171 "InvalidRead", FatalException, "No attribute found!"); 2918 << 2172 return; 2919 if(attribute_node->getNodeType() != xerce << 2173 } 2920 { << 2174 const G4String attName = Transcode(attribute->getName()); 2921 continue; << 2175 const G4String attValue = Transcode(attribute->getValue()); 2922 } << 2176 2923 << 2177 if (attName=="name") { name = GenerateName(attValue); } else 2924 const xercesc::DOMAttr* const attribute = << 2178 if (attName=="lunit") { lunit = G4UnitDefinition::GetValueOf(attValue); 2925 dynamic_cast<xercesc::DOMAttr*>(attribu << 2179 if (G4UnitDefinition::GetCategory(attValue)!="Length") { 2926 if(attribute == nullptr) << 2180 G4Exception("G4GDMLReadSolids::TwistedtrapRead()", "InvalidRead", 2927 { << 2181 FatalException, "Invalid unit for length!"); } 2928 G4Exception("G4GDMLReadSolids::Twistedb << 2182 } else 2929 FatalException, "No attribu << 2183 if (attName=="aunit") { aunit = G4UnitDefinition::GetValueOf(attValue); 2930 return; << 2184 if (G4UnitDefinition::GetCategory(attValue)!="Angle") { 2931 } << 2185 G4Exception("G4GDMLReadSolids::TwistedtrapRead()", "InvalidRead", 2932 const G4String attName = Transcode(attri << 2186 FatalException, "Invalid unit for angle!"); } 2933 const G4String attValue = Transcode(attri << 2187 } else 2934 << 2188 if (attName=="PhiTwist") { PhiTwist = eval.Evaluate(attValue); } else 2935 if(attName == "name") << 2189 if (attName=="z") { z = eval.Evaluate(attValue); } else 2936 { << 2190 if (attName=="Theta") { Theta = eval.Evaluate(attValue); } else 2937 name = GenerateName(attValue); << 2191 if (attName=="Phi") { Phi = eval.Evaluate(attValue); } else 2938 } << 2192 if (attName=="y1") { y1 = eval.Evaluate(attValue); } else 2939 else if(attName == "lunit") << 2193 if (attName=="x1") { x1 = eval.Evaluate(attValue); } else 2940 { << 2194 if (attName=="x2") { x2 = eval.Evaluate(attValue); } else 2941 lunit = G4UnitDefinition::GetValueOf(at << 2195 if (attName=="y2") { y2 = eval.Evaluate(attValue); } else 2942 if(G4UnitDefinition::GetCategory(attVal << 2196 if (attName=="x3") { x3 = eval.Evaluate(attValue); } else 2943 { << 2197 if (attName=="x4") { x4 = eval.Evaluate(attValue); } else 2944 G4Exception("G4GDMLReadSolids::Twiste << 2198 if (attName=="Alph") { Alph = eval.Evaluate(attValue); } 2945 FatalException, "Invalid << 2199 } 2946 } << 2200 2947 } << 2201 2948 else if(attName == "aunit") << 2202 PhiTwist *= aunit; 2949 { << 2203 z *= 0.5*lunit; 2950 aunit = G4UnitDefinition::GetValueOf(at << 2204 Theta *= aunit; 2951 if(G4UnitDefinition::GetCategory(attVal << 2205 Phi *= aunit; 2952 { << 2206 Alph *= aunit; 2953 G4Exception("G4GDMLReadSolids::Twiste << 2207 y1 *= 0.5*lunit; 2954 FatalException, "Invalid << 2208 x1 *= 0.5*lunit; 2955 } << 2209 x2 *= 0.5*lunit; 2956 } << 2210 y2 *= 0.5*lunit; 2957 else if(attName == "PhiTwist") << 2211 x3 *= 0.5*lunit; 2958 { << 2212 x4 *= 0.5*lunit; 2959 PhiTwist = eval.Evaluate(attValue); << 2213 2960 } << 2214 new G4TwistedTrap(name,PhiTwist,z,Theta,Phi,y1,x1,x2,y2,x3,x4,Alph); 2961 else if(attName == "x") << 2215 } 2962 { << 2216 2963 x = eval.Evaluate(attValue); << 2217 void G4GDMLReadSolids:: 2964 } << 2218 TwistedtrdRead(const xercesc::DOMElement* const twistedtrdElement) 2965 else if(attName == "y") << 2219 { 2966 { << 2220 G4String name; 2967 y = eval.Evaluate(attValue); << 2221 G4double lunit = 1.0; 2968 } << 2222 G4double aunit = 1.0; 2969 else if(attName == "z") << 2223 G4double x1 = 0.0; 2970 { << 2224 G4double x2 = 0.0; 2971 z = eval.Evaluate(attValue); << 2225 G4double y1 = 0.0; 2972 } << 2226 G4double y2 = 0.0; 2973 } << 2227 G4double z = 0.0; 2974 << 2228 G4double PhiTwist = 0.0; 2975 PhiTwist *= aunit; << 2229 2976 x *= 0.5 * lunit; << 2230 const xercesc::DOMNamedNodeMap* const attributes 2977 y *= 0.5 * lunit; << 2231 = twistedtrdElement->getAttributes(); 2978 z *= 0.5 * lunit; << 2232 XMLSize_t attributeCount = attributes->getLength(); 2979 << 2233 2980 new G4TwistedBox(name, PhiTwist, x, y, z); << 2234 for (XMLSize_t attribute_index=0; 2981 } << 2235 attribute_index<attributeCount; attribute_index++) 2982 << 2236 { 2983 // ------------------------------------------ << 2237 xercesc::DOMNode* attribute_node = attributes->item(attribute_index); 2984 void G4GDMLReadSolids::TwistedtrapRead( << 2238 2985 const xercesc::DOMElement* const twistedtra << 2239 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE) 2986 { << 2240 { continue; } 2987 G4String name; << 2241 2988 G4double lunit = 1.0; << 2242 const xercesc::DOMAttr* const attribute 2989 G4double aunit = 1.0; << 2243 = dynamic_cast<xercesc::DOMAttr*>(attribute_node); 2990 G4double PhiTwist = 0.0; << 2244 if (!attribute) 2991 G4double z = 0.0; << 2245 { 2992 G4double Theta = 0.0; << 2246 G4Exception("G4GDMLReadSolids::TwistedtrdRead()", 2993 G4double Phi = 0.0; << 2247 "InvalidRead", FatalException, "No attribute found!"); 2994 G4double y1 = 0.0; << 2248 return; 2995 G4double x1 = 0.0; << 2249 } 2996 G4double x2 = 0.0; << 2250 const G4String attName = Transcode(attribute->getName()); 2997 G4double y2 = 0.0; << 2251 const G4String attValue = Transcode(attribute->getValue()); 2998 G4double x3 = 0.0; << 2252 2999 G4double x4 = 0.0; << 2253 if (attName=="name") { name = GenerateName(attValue); } else 3000 G4double Alph = 0.0; << 2254 if (attName=="lunit") { lunit = G4UnitDefinition::GetValueOf(attValue); 3001 << 2255 if (G4UnitDefinition::GetCategory(attValue)!="Length") { 3002 const xercesc::DOMNamedNodeMap* const attri << 2256 G4Exception("G4GDMLReadSolids::TwistedtrdRead()", "InvalidRead", 3003 twistedtrapElement->getAttributes(); << 2257 FatalException, "Invalid unit for length!"); } 3004 XMLSize_t attributeCount = attributes->getL << 2258 } else 3005 << 2259 if (attName=="aunit") { aunit = G4UnitDefinition::GetValueOf(attValue); 3006 for(XMLSize_t attribute_index = 0; attribut << 2260 if (G4UnitDefinition::GetCategory(attValue)!="Angle") { 3007 ++attribute_index) << 2261 G4Exception("G4GDMLReadSolids::TwistedtrdRead()", "InvalidRead", 3008 { << 2262 FatalException, "Invalid unit for angle!"); } 3009 xercesc::DOMNode* attribute_node = attrib << 2263 } else 3010 << 2264 if (attName=="x1") { x1 = eval.Evaluate(attValue); } else 3011 if(attribute_node->getNodeType() != xerce << 2265 if (attName=="x2") { x2 = eval.Evaluate(attValue); } else 3012 { << 2266 if (attName=="y1") { y1 = eval.Evaluate(attValue); } else 3013 continue; << 2267 if (attName=="y2") { y2 = eval.Evaluate(attValue); } else 3014 } << 2268 if (attName=="z") { z = eval.Evaluate(attValue); } else 3015 << 2269 if (attName=="PhiTwist") { PhiTwist = eval.Evaluate(attValue); } 3016 const xercesc::DOMAttr* const attribute = << 2270 } 3017 dynamic_cast<xercesc::DOMAttr*>(attribu << 2271 3018 if(attribute == nullptr) << 2272 x1 *= 0.5*lunit; 3019 { << 2273 x2 *= 0.5*lunit; 3020 G4Exception("G4GDMLReadSolids::Twistedt << 2274 y1 *= 0.5*lunit; 3021 FatalException, "No attribu << 2275 y2 *= 0.5*lunit; 3022 return; << 2276 z *= 0.5*lunit; 3023 } << 2277 PhiTwist *= aunit; 3024 const G4String attName = Transcode(attri << 2278 3025 const G4String attValue = Transcode(attri << 2279 new G4TwistedTrd(name,x1,x2,y1,y2,z,PhiTwist); 3026 << 2280 } 3027 if(attName == "name") << 2281 3028 { << 2282 void G4GDMLReadSolids:: 3029 name = GenerateName(attValue); << 2283 TwistedtubsRead(const xercesc::DOMElement* const twistedtubsElement) 3030 } << 2284 { 3031 else if(attName == "lunit") << 2285 G4String name; 3032 { << 2286 G4double lunit = 1.0; 3033 lunit = G4UnitDefinition::GetValueOf(at << 2287 G4double aunit = 1.0; 3034 if(G4UnitDefinition::GetCategory(attVal << 2288 G4double twistedangle = 0.0; 3035 { << 2289 G4double endinnerrad = 0.0; 3036 G4Exception("G4GDMLReadSolids::Twiste << 2290 G4double endouterrad = 0.0; 3037 FatalException, "Invalid << 2291 G4double zlen = 0.0; 3038 } << 2292 G4double phi = 0.0; 3039 } << 2293 G4double totphi = 0.0; 3040 else if(attName == "aunit") << 2294 G4double midinnerrad = 0.0; 3041 { << 2295 G4double midouterrad = 0.0; 3042 aunit = G4UnitDefinition::GetValueOf(at << 2296 G4double positiveEndz = 0.0; 3043 if(G4UnitDefinition::GetCategory(attVal << 2297 G4double negativeEndz = 0.0; 3044 { << 2298 G4int nseg = 0; 3045 G4Exception("G4GDMLReadSolids::Twiste << 2299 3046 FatalException, "Invalid << 2300 const xercesc::DOMNamedNodeMap* const attributes 3047 } << 2301 = twistedtubsElement->getAttributes(); 3048 } << 2302 XMLSize_t attributeCount = attributes->getLength(); 3049 else if(attName == "PhiTwist") << 2303 3050 { << 2304 for (XMLSize_t attribute_index=0; 3051 PhiTwist = eval.Evaluate(attValue); << 2305 attribute_index<attributeCount; attribute_index++) 3052 } << 2306 { 3053 else if(attName == "z") << 2307 xercesc::DOMNode* attribute_node = attributes->item(attribute_index); 3054 { << 2308 3055 z = eval.Evaluate(attValue); << 2309 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE) 3056 } << 2310 { continue; } 3057 else if(attName == "Theta") << 2311 3058 { << 2312 const xercesc::DOMAttr* const attribute 3059 Theta = eval.Evaluate(attValue); << 2313 = dynamic_cast<xercesc::DOMAttr*>(attribute_node); 3060 } << 2314 if (!attribute) 3061 else if(attName == "Phi") << 2315 { 3062 { << 2316 G4Exception("G4GDMLReadSolids::TwistedtubsRead()", 3063 Phi = eval.Evaluate(attValue); << 2317 "InvalidRead", FatalException, "No attribute found!"); 3064 } << 2318 return; 3065 else if(attName == "y1") << 2319 } 3066 { << 2320 const G4String attName = Transcode(attribute->getName()); 3067 y1 = eval.Evaluate(attValue); << 2321 const G4String attValue = Transcode(attribute->getValue()); 3068 } << 2322 3069 else if(attName == "x1") << 2323 if (attName=="name") { name = GenerateName(attValue); } else 3070 { << 2324 if (attName=="lunit") { lunit = G4UnitDefinition::GetValueOf(attValue); 3071 x1 = eval.Evaluate(attValue); << 2325 if (G4UnitDefinition::GetCategory(attValue)!="Length") { 3072 } << 2326 G4Exception("G4GDMLReadSolids::TwistedtubsRead()", "InvalidRead", 3073 else if(attName == "x2") << 2327 FatalException, "Invalid unit for length!"); } 3074 { << 2328 } else 3075 x2 = eval.Evaluate(attValue); << 2329 if (attName=="aunit") { aunit = G4UnitDefinition::GetValueOf(attValue); 3076 } << 2330 if (G4UnitDefinition::GetCategory(attValue)!="Angle") { 3077 else if(attName == "y2") << 2331 G4Exception("G4GDMLReadSolids::TwistedtubsRead()", "InvalidRead", 3078 { << 2332 FatalException, "Invalid unit for angle!"); } 3079 y2 = eval.Evaluate(attValue); << 2333 } else 3080 } << 2334 if (attName=="twistedangle") { twistedangle=eval.Evaluate(attValue); } else 3081 else if(attName == "x3") << 2335 if (attName=="endinnerrad") { endinnerrad=eval.Evaluate(attValue); } else 3082 { << 2336 if (attName=="endouterrad") { endouterrad=eval.Evaluate(attValue); } else 3083 x3 = eval.Evaluate(attValue); << 2337 if (attName=="zlen") { zlen = eval.Evaluate(attValue); } else 3084 } << 2338 if (attName=="midinnerrad") { midinnerrad=eval.Evaluate(attValue); } else 3085 else if(attName == "x4") << 2339 if (attName=="midouterrad") { midouterrad=eval.Evaluate(attValue); } else 3086 { << 2340 if (attName=="negativeEndz") { negativeEndz = eval.Evaluate(attValue); } else 3087 x4 = eval.Evaluate(attValue); << 2341 if (attName=="positiveEndz") { positiveEndz = eval.Evaluate(attValue); } else 3088 } << 2342 if (attName=="nseg") { nseg = eval.Evaluate(attValue); } else 3089 else if(attName == "Alph") << 2343 if (attName=="totphi") { totphi = eval.Evaluate(attValue); } else 3090 { << 2344 if (attName=="phi") { phi = eval.Evaluate(attValue); } 3091 Alph = eval.Evaluate(attValue); << 2345 } 3092 } << 2346 3093 } << 2347 twistedangle *= aunit; 3094 << 2348 endinnerrad *= lunit; 3095 PhiTwist *= aunit; << 2349 endouterrad *= lunit; 3096 z *= 0.5 * lunit; << 2350 zlen *= 0.5*lunit; 3097 Theta *= aunit; << 2351 midinnerrad *= lunit; 3098 Phi *= aunit; << 2352 midouterrad *= lunit; 3099 Alph *= aunit; << 2353 positiveEndz *= lunit; 3100 y1 *= 0.5 * lunit; << 2354 negativeEndz *= lunit; 3101 x1 *= 0.5 * lunit; << 2355 phi *= aunit; 3102 x2 *= 0.5 * lunit; << 2356 totphi *= aunit; 3103 y2 *= 0.5 * lunit; << 2357 3104 x3 *= 0.5 * lunit; << 2358 if (zlen != 0.0) 3105 x4 *= 0.5 * lunit; << 2359 { 3106 << 2360 if (nseg != 0) 3107 new G4TwistedTrap(name, PhiTwist, z, Theta, << 2361 new G4TwistedTubs(name,twistedangle,endinnerrad,endouterrad,zlen,nseg,totphi); 3108 Alph); << 2362 else 3109 } << 2363 new G4TwistedTubs(name,twistedangle,endinnerrad,endouterrad,zlen,phi); 3110 << 2364 } 3111 // ------------------------------------------ << 2365 else 3112 void G4GDMLReadSolids::TwistedtrdRead( << 2366 { 3113 const xercesc::DOMElement* const twistedtrd << 2367 if (nseg != 0) 3114 { << 2368 new G4TwistedTubs(name,twistedangle,midinnerrad,midouterrad, 3115 G4String name; << 2369 negativeEndz,positiveEndz,nseg,totphi); 3116 G4double lunit = 1.0; << 2370 else 3117 G4double aunit = 1.0; << 2371 new G4TwistedTubs(name,twistedangle,midinnerrad,midouterrad, 3118 G4double x1 = 0.0; << 2372 negativeEndz,positiveEndz,phi); 3119 G4double x2 = 0.0; << 2373 } 3120 G4double y1 = 0.0; << 2374 } 3121 G4double y2 = 0.0; << 2375 3122 G4double z = 0.0; << 2376 G4TwoVector G4GDMLReadSolids:: 3123 G4double PhiTwist = 0.0; << 2377 TwoDimVertexRead(const xercesc::DOMElement* const element, G4double lunit) 3124 << 2378 { 3125 const xercesc::DOMNamedNodeMap* const attri << 2379 G4TwoVector vec; 3126 twistedtrdElement->getAttributes(); << 2380 3127 XMLSize_t attributeCount = attributes->getL << 2381 const xercesc::DOMNamedNodeMap* const attributes = element->getAttributes(); 3128 << 2382 XMLSize_t attributeCount = attributes->getLength(); 3129 for(XMLSize_t attribute_index = 0; attribut << 2383 3130 ++attribute_index) << 2384 for (XMLSize_t attribute_index=0; 3131 { << 2385 attribute_index<attributeCount; attribute_index++) 3132 xercesc::DOMNode* attribute_node = attrib << 2386 { 3133 << 2387 xercesc::DOMNode* attribute_node = attributes->item(attribute_index); 3134 if(attribute_node->getNodeType() != xerce << 2388 3135 { << 2389 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE) 3136 continue; << 2390 { continue; } 3137 } << 2391 3138 << 2392 const xercesc::DOMAttr* const attribute 3139 const xercesc::DOMAttr* const attribute = << 2393 = dynamic_cast<xercesc::DOMAttr*>(attribute_node); 3140 dynamic_cast<xercesc::DOMAttr*>(attribu << 2394 if (!attribute) 3141 if(attribute == nullptr) << 2395 { 3142 { << 2396 G4Exception("G4GDMLReadSolids::TwoDimVertexRead()", 3143 G4Exception("G4GDMLReadSolids::Twistedt << 2397 "InvalidRead", FatalException, "No attribute found!"); 3144 FatalException, "No attribu << 2398 return vec; 3145 return; << 2399 } 3146 } << 2400 const G4String attName = Transcode(attribute->getName()); 3147 const G4String attName = Transcode(attri << 2401 const G4String attValue = Transcode(attribute->getValue()); 3148 const G4String attValue = Transcode(attri << 2402 3149 << 2403 if (attName=="x") { vec.setX(eval.Evaluate(attValue)*lunit); } else 3150 if(attName == "name") << 2404 if (attName=="y") { vec.setY(eval.Evaluate(attValue)*lunit); } 3151 { << 2405 } 3152 name = GenerateName(attValue); << 2406 3153 } << 2407 return vec; 3154 else if(attName == "lunit") << 2408 } 3155 { << 2409 3156 lunit = G4UnitDefinition::GetValueOf(at << 2410 G4GDMLReadSolids::zplaneType G4GDMLReadSolids:: 3157 if(G4UnitDefinition::GetCategory(attVal << 2411 ZplaneRead(const xercesc::DOMElement* const zplaneElement) 3158 { << 2412 { 3159 G4Exception("G4GDMLReadSolids::Twiste << 2413 zplaneType zplane = {0.,0.,0.}; 3160 FatalException, "Invalid << 2414 3161 } << 2415 const xercesc::DOMNamedNodeMap* const attributes 3162 } << 2416 = zplaneElement->getAttributes(); 3163 else if(attName == "aunit") << 2417 XMLSize_t attributeCount = attributes->getLength(); 3164 { << 2418 3165 aunit = G4UnitDefinition::GetValueOf(at << 2419 for (XMLSize_t attribute_index=0; 3166 if(G4UnitDefinition::GetCategory(attVal << 2420 attribute_index<attributeCount; attribute_index++) 3167 { << 2421 { 3168 G4Exception("G4GDMLReadSolids::Twiste << 2422 xercesc::DOMNode* node = attributes->item(attribute_index); 3169 FatalException, "Invalid << 2423 3170 } << 2424 if (node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE) { continue; } 3171 } << 2425 3172 else if(attName == "x1") << 2426 const xercesc::DOMAttr* const attribute 3173 { << 2427 = dynamic_cast<xercesc::DOMAttr*>(node); 3174 x1 = eval.Evaluate(attValue); << 2428 if (!attribute) 3175 } << 2429 { 3176 else if(attName == "x2") << 2430 G4Exception("G4GDMLReadSolids::ZplaneRead()", 3177 { << 2431 "InvalidRead", FatalException, "No attribute found!"); 3178 x2 = eval.Evaluate(attValue); << 2432 return zplane; 3179 } << 2433 } 3180 else if(attName == "y1") << 2434 const G4String attName = Transcode(attribute->getName()); 3181 { << 2435 const G4String attValue = Transcode(attribute->getValue()); 3182 y1 = eval.Evaluate(attValue); << 2436 3183 } << 2437 if (attName=="rmin") { zplane.rmin = eval.Evaluate(attValue); } else 3184 else if(attName == "y2") << 2438 if (attName=="rmax") { zplane.rmax = eval.Evaluate(attValue); } else 3185 { << 2439 if (attName=="z") { zplane.z = eval.Evaluate(attValue); } 3186 y2 = eval.Evaluate(attValue); << 2440 } 3187 } << 2441 3188 else if(attName == "z") << 2442 return zplane; 3189 { << 2443 } 3190 z = eval.Evaluate(attValue); << 2444 G4GDMLReadSolids::rzPointType G4GDMLReadSolids:: 3191 } << 2445 RZPointRead(const xercesc::DOMElement* const zplaneElement) 3192 else if(attName == "PhiTwist") << 2446 { 3193 { << 2447 rzPointType rzpoint = {0.,0.}; 3194 PhiTwist = eval.Evaluate(attValue); << 2448 3195 } << 2449 const xercesc::DOMNamedNodeMap* const attributes 3196 } << 2450 = zplaneElement->getAttributes(); 3197 << 2451 XMLSize_t attributeCount = attributes->getLength(); 3198 x1 *= 0.5 * lunit; << 2452 3199 x2 *= 0.5 * lunit; << 2453 for (XMLSize_t attribute_index=0; 3200 y1 *= 0.5 * lunit; << 2454 attribute_index<attributeCount; attribute_index++) 3201 y2 *= 0.5 * lunit; << 2455 { 3202 z *= 0.5 * lunit; << 2456 xercesc::DOMNode* node = attributes->item(attribute_index); 3203 PhiTwist *= aunit; << 2457 3204 << 2458 if (node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE) { continue; } 3205 new G4TwistedTrd(name, x1, x2, y1, y2, z, P << 2459 3206 } << 2460 const xercesc::DOMAttr* const attribute 3207 << 2461 = dynamic_cast<xercesc::DOMAttr*>(node); 3208 // ------------------------------------------ << 2462 if (!attribute) 3209 void G4GDMLReadSolids::TwistedtubsRead( << 2463 { 3210 const xercesc::DOMElement* const twistedtub << 2464 G4Exception("G4GDMLReadSolids::RZPointRead()", 3211 { << 2465 "InvalidRead", FatalException, "No attribute found!"); 3212 G4String name; << 2466 return rzpoint; 3213 G4double lunit = 1.0; << 2467 } 3214 G4double aunit = 1.0; << 2468 const G4String attName = Transcode(attribute->getName()); 3215 G4double twistedangle = 0.0; << 2469 const G4String attValue = Transcode(attribute->getValue()); 3216 G4double endinnerrad = 0.0; << 2470 3217 G4double endouterrad = 0.0; << 2471 if (attName=="r") { rzpoint.r = eval.Evaluate(attValue); } else 3218 G4double zlen = 0.0; << 2472 if (attName=="z") { rzpoint.z = eval.Evaluate(attValue); } 3219 G4double phi = 0.0; << 2473 } 3220 G4double totphi = 0.0; << 2474 3221 G4double midinnerrad = 0.0; << 2475 return rzpoint; 3222 G4double midouterrad = 0.0; << 2476 3223 G4double positiveEndz = 0.0; << 2477 } 3224 G4double negativeEndz = 0.0; << 2478 3225 G4int nseg = 0; << 2479 void G4GDMLReadSolids:: 3226 << 2480 PropertyRead(const xercesc::DOMElement* const propertyElement, 3227 const xercesc::DOMNamedNodeMap* const attri << 2481 G4OpticalSurface* opticalsurface) 3228 twistedtubsElement->getAttributes(); << 2482 { 3229 XMLSize_t attributeCount = attributes->getL << 2483 G4String name; 3230 << 2484 G4String ref; 3231 for(XMLSize_t attribute_index = 0; attribut << 2485 G4GDMLMatrix matrix; 3232 ++attribute_index) << 2486 3233 { << 2487 const xercesc::DOMNamedNodeMap* const attributes 3234 xercesc::DOMNode* attribute_node = attrib << 2488 = propertyElement->getAttributes(); 3235 << 2489 XMLSize_t attributeCount = attributes->getLength(); 3236 if(attribute_node->getNodeType() != xerce << 2490 3237 { << 2491 for (XMLSize_t attribute_index=0; 3238 continue; << 2492 attribute_index<attributeCount; attribute_index++) 3239 } << 2493 { 3240 << 2494 xercesc::DOMNode* attribute_node = attributes->item(attribute_index); 3241 const xercesc::DOMAttr* const attribute = << 2495 3242 dynamic_cast<xercesc::DOMAttr*>(attribu << 2496 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE) 3243 if(attribute == nullptr) << 2497 { continue; } 3244 { << 2498 3245 G4Exception("G4GDMLReadSolids::Twistedt << 2499 const xercesc::DOMAttr* const attribute 3246 FatalException, "No attribu << 2500 = dynamic_cast<xercesc::DOMAttr*>(attribute_node); 3247 return; << 2501 if (!attribute) 3248 } << 2502 { 3249 const G4String attName = Transcode(attri << 2503 G4Exception("G4GDMLReadSolids::PropertyRead()", "InvalidRead", 3250 const G4String attValue = Transcode(attri << 2504 FatalException, "No attribute found!"); 3251 << 2505 return; 3252 if(attName == "name") << 2506 } 3253 { << 2507 const G4String attName = Transcode(attribute->getName()); 3254 name = GenerateName(attValue); << 2508 const G4String attValue = Transcode(attribute->getValue()); 3255 } << 2509 3256 else if(attName == "lunit") << 2510 if (attName=="name") { name = GenerateName(attValue); } else 3257 { << 2511 if (attName=="ref") { matrix = GetMatrix(ref=attValue); } 3258 lunit = G4UnitDefinition::GetValueOf(at << 2512 } 3259 if(G4UnitDefinition::GetCategory(attVal << 2513 3260 { << 2514 /* 3261 G4Exception("G4GDMLReadSolids::Twiste << 2515 if (matrix.GetCols() != 2) 3262 FatalException, "Invalid << 2516 { 3263 } << 2517 G4String error_msg = "Referenced matrix '" + ref 3264 } << 2518 + "' should have \n two columns as a property table for opticalsurface: " 3265 else if(attName == "aunit") << 2519 + opticalsurface->GetName(); 3266 { << 2520 G4Exception("G4GDMLReadSolids::PropertyRead()", "InvalidRead", 3267 aunit = G4UnitDefinition::GetValueOf(at << 2521 FatalException, error_msg); 3268 if(G4UnitDefinition::GetCategory(attVal << 2522 } 3269 { << 2523 */ 3270 G4Exception("G4GDMLReadSolids::Twiste << 2524 3271 FatalException, "Invalid << 2525 if (matrix.GetRows() == 0) { return; } 3272 } << 2526 3273 } << 2527 G4MaterialPropertiesTable* matprop=opticalsurface->GetMaterialPropertiesTable(); 3274 else if(attName == "twistedangle") << 2528 if (!matprop) 3275 { << 2529 { 3276 twistedangle = eval.Evaluate(attValue); << 2530 matprop = new G4MaterialPropertiesTable(); 3277 } << 2531 opticalsurface->SetMaterialPropertiesTable(matprop); 3278 else if(attName == "endinnerrad") << 2532 } 3279 { << 2533 if (matrix.GetCols() == 1) // constant property assumed 3280 endinnerrad = eval.Evaluate(attValue); << 2534 { 3281 } << 2535 matprop->AddConstProperty(Strip(name), matrix.Get(0,0)); 3282 else if(attName == "endouterrad") << 2536 } 3283 { << 2537 else // build the material properties vector 3284 endouterrad = eval.Evaluate(attValue); << 2538 { 3285 } << 2539 G4MaterialPropertyVector* propvect = new G4MaterialPropertyVector(); 3286 else if(attName == "zlen") << 2540 for (size_t i=0; i<matrix.GetRows(); i++) 3287 { << 2541 { 3288 zlen = eval.Evaluate(attValue); << 2542 propvect->InsertValues(matrix.Get(i,0),matrix.Get(i,1)); 3289 } << 2543 } 3290 else if(attName == "midinnerrad") << 2544 matprop->AddProperty(Strip(name),propvect); 3291 { << 2545 } 3292 midinnerrad = eval.Evaluate(attValue); << 2546 } 3293 } << 2547 3294 else if(attName == "midouterrad") << 2548 void G4GDMLReadSolids:: 3295 { << 2549 OpticalSurfaceRead(const xercesc::DOMElement* const opticalsurfaceElement) 3296 midouterrad = eval.Evaluate(attValue); << 2550 { 3297 } << 2551 G4String name; 3298 else if(attName == "negativeEndz") << 2552 G4String smodel; 3299 { << 2553 G4String sfinish; 3300 negativeEndz = eval.Evaluate(attValue); << 2554 G4String stype; 3301 } << 2555 G4double value = 0.0; 3302 else if(attName == "positiveEndz") << 2556 3303 { << 2557 const xercesc::DOMNamedNodeMap* const attributes 3304 positiveEndz = eval.Evaluate(attValue); << 2558 = opticalsurfaceElement->getAttributes(); 3305 } << 2559 XMLSize_t attributeCount = attributes->getLength(); 3306 else if(attName == "nseg") << 2560 3307 { << 2561 for (XMLSize_t attribute_index=0; 3308 nseg = eval.Evaluate(attValue); << 2562 attribute_index<attributeCount; attribute_index++) 3309 } << 2563 { 3310 else if(attName == "totphi") << 2564 xercesc::DOMNode* attribute_node = attributes->item(attribute_index); 3311 { << 2565 3312 totphi = eval.Evaluate(attValue); << 2566 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE) 3313 } << 2567 { continue; } 3314 else if(attName == "phi") << 2568 3315 { << 2569 const xercesc::DOMAttr* const attribute 3316 phi = eval.Evaluate(attValue); << 2570 = dynamic_cast<xercesc::DOMAttr*>(attribute_node); 3317 } << 2571 if (!attribute) 3318 } << 2572 { 3319 << 2573 G4Exception("G4GDMLReadSolids::OpticalSurfaceRead()", 3320 twistedangle *= aunit; << 2574 "InvalidRead", FatalException, "No attribute found!"); 3321 endinnerrad *= lunit; << 2575 return; 3322 endouterrad *= lunit; << 2576 } 3323 zlen *= 0.5 * lunit; << 2577 const G4String attName = Transcode(attribute->getName()); 3324 midinnerrad *= lunit; << 2578 const G4String attValue = Transcode(attribute->getValue()); 3325 midouterrad *= lunit; << 2579 3326 positiveEndz *= lunit; << 2580 if (attName=="name") { name = GenerateName(attValue); } else 3327 negativeEndz *= lunit; << 2581 if (attName=="model") { smodel = attValue; } else 3328 phi *= aunit; << 2582 if (attName=="finish") { sfinish = attValue; } else 3329 totphi *= aunit; << 2583 if (attName=="type") { stype = attValue; } else 3330 << 2584 if (attName=="value") { value = eval.Evaluate(attValue); } 3331 if(zlen != 0.0) << 2585 } 3332 { << 2586 3333 if(nseg != 0) << 2587 G4OpticalSurfaceModel model; 3334 new G4TwistedTubs(name, twistedangle, e << 2588 G4OpticalSurfaceFinish finish; 3335 nseg, totphi); << 2589 G4SurfaceType type; 3336 else << 2590 3337 new G4TwistedTubs(name, twistedangle, e << 2591 if ((smodel=="glisur") || (smodel=="0")) { model = glisur; } else 3338 phi); << 2592 if ((smodel=="unified") || (smodel=="1")) { model = unified; } else 3339 } << 2593 if ((smodel=="LUT") || (smodel=="2")) { model = LUT; } 3340 else << 2594 else { model = dichroic; } 3341 { << 2595 3342 if(nseg != 0) << 2596 if ((sfinish=="polished") || (sfinish=="0")) 3343 new G4TwistedTubs(name, twistedangle, m << 2597 { finish = polished; } else 3344 negativeEndz, positiv << 2598 if ((sfinish=="polishedfrontpainted") || (sfinish=="1")) 3345 else << 2599 { finish = polishedfrontpainted; } else 3346 new G4TwistedTubs(name, twistedangle, m << 2600 if ((sfinish=="polishedbackpainted") || (sfinish=="2")) 3347 negativeEndz, positiv << 2601 { finish = polishedbackpainted; } else 3348 } << 2602 if ((sfinish=="ground") || (sfinish=="3")) 3349 } << 2603 { finish = ground; } else 3350 << 2604 if ((sfinish=="groundfrontpainted") || (sfinish=="4")) 3351 // ------------------------------------------ << 2605 { finish = groundfrontpainted; } else 3352 G4TwoVector G4GDMLReadSolids::TwoDimVertexRea << 2606 if ((sfinish=="groundbackpainted") || (sfinish=="5")) 3353 const xercesc::DOMElement* const element, G << 2607 { finish = groundbackpainted; } else 3354 { << 2608 if ((sfinish=="polishedlumirrorair") || (sfinish=="6")) 3355 G4TwoVector vec; << 2609 { finish = polishedlumirrorair; } else 3356 << 2610 if ((sfinish=="polishedlumirrorglue") || (sfinish=="7")) 3357 const xercesc::DOMNamedNodeMap* const attri << 2611 { finish = polishedlumirrorglue; } else 3358 XMLSize_t attributeCount << 2612 if ((sfinish=="polishedair") || (sfinish=="8")) 3359 << 2613 { finish = polishedair; } else 3360 for(XMLSize_t attribute_index = 0; attribut << 2614 if ((sfinish=="polishedteflonair") || (sfinish=="9")) 3361 ++attribute_index) << 2615 { finish = polishedteflonair; } else 3362 { << 2616 if ((sfinish=="polishedtioair") || (sfinish=="10")) 3363 xercesc::DOMNode* attribute_node = attrib << 2617 { finish = polishedtioair; } else 3364 << 2618 if ((sfinish=="polishedtyvekair") || (sfinish=="11")) 3365 if(attribute_node->getNodeType() != xerce << 2619 { finish = polishedtyvekair; } else 3366 { << 2620 if ((sfinish=="polishedvm2000air") || (sfinish=="12")) 3367 continue; << 2621 { finish = polishedvm2000air; } else 3368 } << 2622 if ((sfinish=="polishedvm2000glue") || (sfinish=="13")) 3369 << 2623 { finish = polishedvm2000glue; } else 3370 const xercesc::DOMAttr* const attribute = << 2624 if ((sfinish=="etchedlumirrorair") || (sfinish=="14")) 3371 dynamic_cast<xercesc::DOMAttr*>(attribu << 2625 { finish = etchedlumirrorair; } else 3372 if(attribute == nullptr) << 2626 if ((sfinish=="etchedlumirrorglue") || (sfinish=="15")) 3373 { << 2627 { finish = etchedlumirrorglue; } else 3374 G4Exception("G4GDMLReadSolids::TwoDimVe << 2628 if ((sfinish=="etchedair") || (sfinish=="16")) 3375 FatalException, "No attribu << 2629 { finish = etchedair; } else 3376 return vec; << 2630 if ((sfinish=="etchedteflonair") || (sfinish=="17")) 3377 } << 2631 { finish = etchedteflonair; } else 3378 const G4String attName = Transcode(attri << 2632 if ((sfinish=="etchedtioair") || (sfinish=="18")) 3379 const G4String attValue = Transcode(attri << 2633 { finish = etchedtioair; } else 3380 << 2634 if ((sfinish=="etchedtyvekair") || (sfinish=="19")) 3381 if(attName == "x") << 2635 { finish = etchedtyvekair; } else 3382 { << 2636 if ((sfinish=="etchedvm2000air") || (sfinish=="20")) 3383 vec.setX(eval.Evaluate(attValue) * luni << 2637 { finish = etchedvm2000air; } else 3384 } << 2638 if ((sfinish=="etchedvm2000glue") || (sfinish=="21")) 3385 else if(attName == "y") << 2639 { finish = etchedvm2000glue; } else 3386 { << 2640 if ((sfinish=="groundlumirrorair") || (sfinish=="22")) 3387 vec.setY(eval.Evaluate(attValue) * luni << 2641 { finish = groundlumirrorair; } else 3388 } << 2642 if ((sfinish=="groundlumirrorglue") || (sfinish=="23")) 3389 } << 2643 { finish = groundlumirrorglue; } else 3390 << 2644 if ((sfinish=="groundair") || (sfinish=="24")) 3391 return vec; << 2645 { finish = groundair; } else 3392 } << 2646 if ((sfinish=="groundteflonair") || (sfinish=="25")) 3393 << 2647 { finish = groundteflonair; } else 3394 // ------------------------------------------ << 2648 if ((sfinish=="groundtioair") || (sfinish=="26")) 3395 G4GDMLReadSolids::zplaneType G4GDMLReadSolids << 2649 { finish = groundtioair; } else 3396 const xercesc::DOMElement* const zplaneElem << 2650 if ((sfinish=="groundtyvekair") || (sfinish=="27")) 3397 { << 2651 { finish = groundtyvekair; } else 3398 zplaneType zplane = { 0., 0., 0. }; << 2652 if ((sfinish=="groundvm2000air") || (sfinish=="28")) 3399 << 2653 { finish = groundvm2000air; } 3400 const xercesc::DOMNamedNodeMap* const attri << 2654 else { finish = groundvm2000glue; } 3401 zplaneElement->getAttributes(); << 2655 3402 XMLSize_t attributeCount = attributes->getL << 2656 if ((stype=="dielectric_metal") || (stype=="0")) 3403 << 2657 { type = dielectric_metal; } else 3404 for(XMLSize_t attribute_index = 0; attribut << 2658 if ((stype=="dielectric_dielectric") || (stype=="1")) 3405 ++attribute_index) << 2659 { type = dielectric_dielectric; } else 3406 { << 2660 if ((stype=="dielectric_LUT") || (stype=="2")) 3407 xercesc::DOMNode* node = attributes->item << 2661 { type = dielectric_LUT; } else 3408 << 2662 if ((stype=="dielectric_dichroic") || (stype=="3")) 3409 if(node->getNodeType() != xercesc::DOMNod << 2663 { type = dielectric_dichroic; } else 3410 { << 2664 if ((stype=="firsov") || (stype=="4")) 3411 continue; << 2665 { type = firsov; } 3412 } << 2666 else { type = x_ray; } 3413 << 2667 3414 const xercesc::DOMAttr* const attribute = << 2668 G4OpticalSurface* opticalsurface 3415 dynamic_cast<xercesc::DOMAttr*>(node); << 2669 = new G4OpticalSurface(name,model,finish,type,value); 3416 if(attribute == nullptr) << 2670 3417 { << 2671 for (xercesc::DOMNode* iter = opticalsurfaceElement->getFirstChild(); 3418 G4Exception("G4GDMLReadSolids::ZplaneRe << 2672 iter != 0;iter = iter->getNextSibling()) 3419 FatalException, "No attribu << 2673 { 3420 return zplane; << 2674 if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE) { continue; } 3421 } << 2675 3422 const G4String attName = Transcode(attri << 2676 const xercesc::DOMElement* const child 3423 const G4String attValue = Transcode(attri << 2677 = dynamic_cast<xercesc::DOMElement*>(iter); 3424 << 2678 if (!child) 3425 if(attName == "rmin") << 2679 { 3426 { << 2680 G4Exception("G4GDMLReadSolids::OpticalSurfaceRead()", 3427 zplane.rmin = eval.Evaluate(attValue); << 2681 "InvalidRead", FatalException, "No child found!"); 3428 } << 2682 return; 3429 else if(attName == "rmax") << 2683 } 3430 { << 2684 const G4String tag = Transcode(child->getTagName()); 3431 zplane.rmax = eval.Evaluate(attValue); << 2685 3432 } << 2686 if (tag=="property") { PropertyRead(child,opticalsurface); } 3433 else if(attName == "z") << 2687 } 3434 { << 2688 } 3435 zplane.z = eval.Evaluate(attValue); << 2689 3436 } << 2690 void G4GDMLReadSolids::SolidsRead(const xercesc::DOMElement* const solidsElement) 3437 } << 2691 { 3438 << 2692 G4cout << "G4GDML: Reading solids..." << G4endl; 3439 return zplane; << 2693 >> 2694 for (xercesc::DOMNode* iter = solidsElement->getFirstChild(); >> 2695 iter != 0; iter = iter->getNextSibling()) >> 2696 { >> 2697 if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE) { continue; } >> 2698 >> 2699 const xercesc::DOMElement* const child >> 2700 = dynamic_cast<xercesc::DOMElement*>(iter); >> 2701 if (!child) >> 2702 { >> 2703 G4Exception("G4GDMLReadSolids::SolidsRead()", >> 2704 "InvalidRead", FatalException, "No child found!"); >> 2705 return; >> 2706 } >> 2707 const G4String tag = Transcode(child->getTagName()); >> 2708 if (tag=="define") { DefineRead(child); } else >> 2709 if (tag=="box") { BoxRead(child); } else >> 2710 if (tag=="cone") { ConeRead(child); } else >> 2711 if (tag=="elcone") { ElconeRead(child); } else >> 2712 if (tag=="ellipsoid") { EllipsoidRead(child); }else >> 2713 if (tag=="eltube") { EltubeRead(child); } else >> 2714 if (tag=="xtru") { XtruRead(child); } else >> 2715 if (tag=="hype") { HypeRead(child); } else >> 2716 if (tag=="intersection") { BooleanRead(child,INTERSECTION); } else >> 2717 if (tag=="multiUnion") { MultiUnionRead(child); } else >> 2718 if (tag=="orb") { OrbRead(child); } else >> 2719 if (tag=="para") { ParaRead(child); } else >> 2720 if (tag=="paraboloid") { ParaboloidRead(child); } else >> 2721 if (tag=="polycone") { PolyconeRead(child); } else >> 2722 if (tag=="genericPolycone") { GenericPolyconeRead(child); } else >> 2723 if (tag=="polyhedra") { PolyhedraRead(child); } else >> 2724 if (tag=="genericPolyhedra") { GenericPolyhedraRead(child); } else >> 2725 if (tag=="reflectedSolid") { ReflectedSolidRead(child); } else >> 2726 if (tag=="scaledSolid") { ScaledSolidRead(child); } else >> 2727 if (tag=="sphere") { SphereRead(child); } else >> 2728 if (tag=="subtraction") { BooleanRead(child,SUBTRACTION); } else >> 2729 if (tag=="tessellated") { TessellatedRead(child); } else >> 2730 if (tag=="tet") { TetRead(child); } else >> 2731 if (tag=="torus") { TorusRead(child); } else >> 2732 if (tag=="arb8") { GenTrapRead(child); } else >> 2733 if (tag=="trap") { TrapRead(child); } else >> 2734 if (tag=="trd") { TrdRead(child); } else >> 2735 if (tag=="tube") { TubeRead(child); } else >> 2736 if (tag=="cutTube") { CutTubeRead(child); } else >> 2737 if (tag=="twistedbox") { TwistedboxRead(child); } else >> 2738 if (tag=="twistedtrap") { TwistedtrapRead(child); } else >> 2739 if (tag=="twistedtrd") { TwistedtrdRead(child); } else >> 2740 if (tag=="twistedtubs") { TwistedtubsRead(child); } else >> 2741 if (tag=="union") { BooleanRead(child,UNION); } else >> 2742 if (tag=="opticalsurface") { OpticalSurfaceRead(child); } else >> 2743 if (tag=="loop") { LoopRead(child,&G4GDMLRead::SolidsRead); } >> 2744 else >> 2745 { >> 2746 G4String error_msg = "Unknown tag in solids: " + tag; >> 2747 G4Exception("G4GDMLReadSolids::SolidsRead()", "ReadError", >> 2748 FatalException, error_msg); >> 2749 } >> 2750 } 3440 } 2751 } 3441 2752 3442 // ------------------------------------------ << 2753 G4VSolid* G4GDMLReadSolids::GetSolid(const G4String& ref) const 3443 G4GDMLReadSolids::rzPointType G4GDMLReadSolid << 3444 const xercesc::DOMElement* const zplaneElem << 3445 { 2754 { 3446 rzPointType rzpoint = { 0., 0. }; << 2755 G4VSolid* solidPtr = G4SolidStore::GetInstance()->GetSolid(ref,false); 3447 2756 3448 const xercesc::DOMNamedNodeMap* const attri << 2757 if (!solidPtr) 3449 zplaneElement->getAttributes(); << 2758 { 3450 XMLSize_t attributeCount = attributes->getL << 2759 G4String error_msg = "Referenced solid '" + ref + "' was not found!"; 3451 << 2760 G4Exception("G4GDMLReadSolids::GetSolid()", "ReadError", 3452 for(XMLSize_t attribute_index = 0; attribut << 2761 FatalException, error_msg); 3453 ++attribute_index) << 2762 } 3454 { << 3455 xercesc::DOMNode* node = attributes->item << 3456 << 3457 if(node->getNodeType() != xercesc::DOMNod << 3458 { << 3459 continue; << 3460 } << 3461 << 3462 const xercesc::DOMAttr* const attribute = << 3463 dynamic_cast<xercesc::DOMAttr*>(node); << 3464 if(attribute == nullptr) << 3465 { << 3466 G4Exception("G4GDMLReadSolids::RZPointR << 3467 FatalException, "No attribu << 3468 return rzpoint; << 3469 } << 3470 const G4String attName = Transcode(attri << 3471 const G4String attValue = Transcode(attri << 3472 << 3473 if(attName == "r") << 3474 { << 3475 rzpoint.r = eval.Evaluate(attValue); << 3476 } << 3477 else if(attName == "z") << 3478 { << 3479 rzpoint.z = eval.Evaluate(attValue); << 3480 } << 3481 } << 3482 2763 3483 return rzpoint; << 2764 return solidPtr; 3484 } 2765 } 3485 2766 3486 // ------------------------------------------ << 2767 G4SurfaceProperty* G4GDMLReadSolids:: 3487 void G4GDMLReadSolids::PropertyRead( << 2768 GetSurfaceProperty(const G4String& ref) const 3488 const xercesc::DOMElement* const propertyEl << 3489 G4OpticalSurface* opticalsurface) << 3490 { << 3491 G4String name; << 3492 G4String ref; << 3493 G4GDMLMatrix matrix; << 3494 << 3495 const xercesc::DOMNamedNodeMap* const attri << 3496 propertyElement->getAttributes(); << 3497 XMLSize_t attributeCount = attributes->getL << 3498 << 3499 for(XMLSize_t attribute_index = 0; attribut << 3500 ++attribute_index) << 3501 { << 3502 xercesc::DOMNode* attribute_node = attrib << 3503 << 3504 if(attribute_node->getNodeType() != xerce << 3505 { << 3506 continue; << 3507 } << 3508 << 3509 const xercesc::DOMAttr* const attribute = << 3510 dynamic_cast<xercesc::DOMAttr*>(attribu << 3511 if(attribute == nullptr) << 3512 { << 3513 G4Exception("G4GDMLReadSolids::Property << 3514 FatalException, "No attribu << 3515 return; << 3516 } << 3517 const G4String attName = Transcode(attri << 3518 const G4String attValue = Transcode(attri << 3519 << 3520 if(attName == "name") << 3521 { << 3522 name = GenerateName(attValue); << 3523 } << 3524 else if(attName == "ref") << 3525 { << 3526 matrix = GetMatrix(ref = attValue); << 3527 } << 3528 } << 3529 << 3530 /* << 3531 if (matrix.GetCols() != 2) << 3532 { << 3533 G4String error_msg = "Referenced matrix ' << 3534 + "' should have \n two columns as << 3535 opticalsurface: " << 3536 + opticalsurface->GetName(); << 3537 G4Exception("G4GDMLReadSolids::PropertyRe << 3538 FatalException, error_msg); << 3539 } << 3540 */ << 3541 << 3542 if(matrix.GetRows() == 0) << 3543 { << 3544 return; << 3545 } << 3546 << 3547 G4MaterialPropertiesTable* matprop = << 3548 opticalsurface->GetMaterialPropertiesTabl << 3549 if(matprop == nullptr) << 3550 { << 3551 matprop = new G4MaterialPropertiesTable() << 3552 opticalsurface->SetMaterialPropertiesTabl << 3553 } << 3554 if(matrix.GetCols() == 1) // constant prop << 3555 { << 3556 matprop->AddConstProperty(Strip(name), ma << 3557 } << 3558 else // build the material properties vect << 3559 { << 3560 G4MaterialPropertyVector* propvect; << 3561 G4String temp = name + ref; << 3562 // first check if it was already built << 3563 if(mapOfMatPropVects.find(temp) == mapOfM << 3564 { << 3565 // if not create a new one << 3566 propvect = new G4MaterialPropertyVector << 3567 for(size_t i = 0; i < matrix.GetRows(); << 3568 { << 3569 propvect->InsertValues(matrix.Get(i, << 3570 } << 3571 // and add it to the list for potential << 3572 mapOfMatPropVects[temp] = propvect; << 3573 } << 3574 else << 3575 { << 3576 propvect = mapOfMatPropVects[temp]; << 3577 } << 3578 << 3579 matprop->AddProperty(Strip(name), propvec << 3580 } << 3581 } << 3582 << 3583 // ------------------------------------------ << 3584 void G4GDMLReadSolids::OpticalSurfaceRead( << 3585 const xercesc::DOMElement* const opticalsur << 3586 { 2769 { 3587 G4String name; << 2770 const G4SurfacePropertyTable* surfaceList 3588 G4String smodel; << 2771 = G4SurfaceProperty::GetSurfacePropertyTable(); 3589 G4String sfinish; << 2772 const size_t surfaceCount = surfaceList->size(); 3590 G4String stype; << 3591 G4double value = 0.0; << 3592 << 3593 const xercesc::DOMNamedNodeMap* const attri << 3594 opticalsurfaceElement->getAttributes(); << 3595 XMLSize_t attributeCount = attributes->getL << 3596 << 3597 for(XMLSize_t attribute_index = 0; attribut << 3598 ++attribute_index) << 3599 { << 3600 xercesc::DOMNode* attribute_node = attrib << 3601 << 3602 if(attribute_node->getNodeType() != xerce << 3603 { << 3604 continue; << 3605 } << 3606 << 3607 const xercesc::DOMAttr* const attribute = << 3608 dynamic_cast<xercesc::DOMAttr*>(attribu << 3609 if(attribute == nullptr) << 3610 { << 3611 G4Exception("G4GDMLReadSolids::OpticalS << 3612 FatalException, "No attribu << 3613 return; << 3614 } << 3615 const G4String attName = Transcode(attri << 3616 const G4String attValue = Transcode(attri << 3617 << 3618 if(attName == "name") << 3619 { << 3620 name = GenerateName(attValue); << 3621 } << 3622 else if(attName == "model") << 3623 { << 3624 smodel = attValue; << 3625 } << 3626 else if(attName == "finish") << 3627 { << 3628 sfinish = attValue; << 3629 } << 3630 else if(attName == "type") << 3631 { << 3632 stype = attValue; << 3633 } << 3634 else if(attName == "value") << 3635 { << 3636 value = eval.Evaluate(attValue); << 3637 } << 3638 } << 3639 << 3640 G4OpticalSurfaceModel model; << 3641 G4OpticalSurfaceFinish finish; << 3642 G4SurfaceType type; << 3643 << 3644 if((smodel == "glisur") || (smodel == "0")) << 3645 { << 3646 model = glisur; << 3647 } << 3648 else if((smodel == "unified") || (smodel == << 3649 { << 3650 model = unified; << 3651 } << 3652 else if((smodel == "LUT") || (smodel == "2" << 3653 { << 3654 model = LUT; << 3655 } << 3656 else if((smodel == "DAVIS") || (smodel == " << 3657 { << 3658 model = DAVIS; << 3659 } << 3660 else << 3661 { << 3662 model = dichroic; << 3663 } << 3664 << 3665 if((sfinish == "polished") || (sfinish == " << 3666 { << 3667 finish = polished; << 3668 } << 3669 else if((sfinish == "polishedfrontpainted") << 3670 { << 3671 finish = polishedfrontpainted; << 3672 } << 3673 else if((sfinish == "polishedbackpainted") << 3674 { << 3675 finish = polishedbackpainted; << 3676 } << 3677 else if((sfinish == "ground") || (sfinish = << 3678 { << 3679 finish = ground; << 3680 } << 3681 else if((sfinish == "groundfrontpainted") | << 3682 { << 3683 finish = groundfrontpainted; << 3684 } << 3685 else if((sfinish == "groundbackpainted") || << 3686 { << 3687 finish = groundbackpainted; << 3688 } << 3689 else if((sfinish == "polishedlumirrorair") << 3690 { << 3691 finish = polishedlumirrorair; << 3692 } << 3693 else if((sfinish == "polishedlumirrorglue") << 3694 { << 3695 finish = polishedlumirrorglue; << 3696 } << 3697 else if((sfinish == "polishedair") || (sfin << 3698 { << 3699 finish = polishedair; << 3700 } << 3701 else if((sfinish == "polishedteflonair") || << 3702 { << 3703 finish = polishedteflonair; << 3704 } << 3705 else if((sfinish == "polishedtioair") || (s << 3706 { << 3707 finish = polishedtioair; << 3708 } << 3709 else if((sfinish == "polishedtyvekair") || << 3710 { << 3711 finish = polishedtyvekair; << 3712 } << 3713 else if((sfinish == "polishedvm2000air") || << 3714 { << 3715 finish = polishedvm2000air; << 3716 } << 3717 else if((sfinish == "polishedvm2000glue") | << 3718 { << 3719 finish = polishedvm2000glue; << 3720 } << 3721 else if((sfinish == "etchedlumirrorair") || << 3722 { << 3723 finish = etchedlumirrorair; << 3724 } << 3725 else if((sfinish == "etchedlumirrorglue") | << 3726 { << 3727 finish = etchedlumirrorglue; << 3728 } << 3729 else if((sfinish == "etchedair") || (sfinis << 3730 { << 3731 finish = etchedair; << 3732 } << 3733 else if((sfinish == "etchedteflonair") || ( << 3734 { << 3735 finish = etchedteflonair; << 3736 } << 3737 else if((sfinish == "etchedtioair") || (sfi << 3738 { << 3739 finish = etchedtioair; << 3740 } << 3741 else if((sfinish == "etchedtyvekair") || (s << 3742 { << 3743 finish = etchedtyvekair; << 3744 } << 3745 else if((sfinish == "etchedvm2000air") || ( << 3746 { << 3747 finish = etchedvm2000air; << 3748 } << 3749 else if((sfinish == "etchedvm2000glue") || << 3750 { << 3751 finish = etchedvm2000glue; << 3752 } << 3753 else if((sfinish == "groundlumirrorair") || << 3754 { << 3755 finish = groundlumirrorair; << 3756 } << 3757 else if((sfinish == "groundlumirrorglue") | << 3758 { << 3759 finish = groundlumirrorglue; << 3760 } << 3761 else if((sfinish == "groundair") || (sfinis << 3762 { << 3763 finish = groundair; << 3764 } << 3765 else if((sfinish == "groundteflonair") || ( << 3766 { << 3767 finish = groundteflonair; << 3768 } << 3769 else if((sfinish == "groundtioair") || (sfi << 3770 { << 3771 finish = groundtioair; << 3772 } << 3773 else if((sfinish == "groundtyvekair") || (s << 3774 { << 3775 finish = groundtyvekair; << 3776 } << 3777 else if((sfinish == "groundvm2000air") || ( << 3778 { << 3779 finish = groundvm2000air; << 3780 } << 3781 else if((sfinish == "groundvm2000glue") || << 3782 { << 3783 finish = groundvm2000glue; << 3784 } << 3785 else if((sfinish == "Rough_LUT") || (sfinis << 3786 { << 3787 finish = Rough_LUT; << 3788 } << 3789 else if((sfinish == "RoughTeflon_LUT") || ( << 3790 { << 3791 finish = RoughTeflon_LUT; << 3792 } << 3793 else if((sfinish == "RoughESR_LUT") || (sfi << 3794 { << 3795 finish = RoughESR_LUT; << 3796 } << 3797 else if((sfinish == "RoughESRGrease_LUT") | << 3798 { << 3799 finish = RoughESRGrease_LUT; << 3800 } << 3801 else if((sfinish == "Polished_LUT") || (sfi << 3802 { << 3803 finish = Polished_LUT; << 3804 } << 3805 else if((sfinish == "PolishedTeflon_LUT") | << 3806 { << 3807 finish = PolishedTeflon_LUT; << 3808 } << 3809 else if((sfinish == "PolishedESR_LUT") || ( << 3810 { << 3811 finish = PolishedESR_LUT; << 3812 } << 3813 else if((sfinish == "PolishedESRGrease_LUT" << 3814 { << 3815 finish = PolishedESRGrease_LUT; << 3816 } << 3817 else << 3818 { << 3819 finish = Detector_LUT; << 3820 } << 3821 << 3822 if((stype == "dielectric_metal") || (stype << 3823 { << 3824 type = dielectric_metal; << 3825 } << 3826 else if((stype == "dielectric_dielectric") << 3827 { << 3828 type = dielectric_dielectric; << 3829 } << 3830 else if((stype == "dielectric_LUT") || (sty << 3831 { << 3832 type = dielectric_LUT; << 3833 } << 3834 else if((stype == "dielectric_LUTDAVIS") || << 3835 { << 3836 type = dielectric_LUTDAVIS; << 3837 } << 3838 else if((stype == "dielectric_dichroic") || << 3839 { << 3840 type = dielectric_dichroic; << 3841 } << 3842 else if((stype == "firsov") || (stype == "5 << 3843 { << 3844 type = firsov; << 3845 } << 3846 else << 3847 { << 3848 type = x_ray; << 3849 } << 3850 << 3851 G4OpticalSurface* opticalsurface = << 3852 new G4OpticalSurface(name, model, finish, << 3853 << 3854 for(xercesc::DOMNode* iter = opticalsurface << 3855 iter != nullptr; iter = iter->getNextSi << 3856 { << 3857 if(iter->getNodeType() != xercesc::DOMNod << 3858 { << 3859 continue; << 3860 } << 3861 << 3862 const xercesc::DOMElement* const child = << 3863 dynamic_cast<xercesc::DOMElement*>(iter << 3864 if(child == nullptr) << 3865 { << 3866 G4Exception("G4GDMLReadSolids::OpticalS << 3867 FatalException, "No child f << 3868 return; << 3869 } << 3870 const G4String tag = Transcode(child->get << 3871 << 3872 if(tag == "property") << 3873 { << 3874 PropertyRead(child, opticalsurface); << 3875 } << 3876 } << 3877 } << 3878 2773 3879 // ------------------------------------------ << 2774 for (size_t i=0; i<surfaceCount; i++) 3880 void G4GDMLReadSolids::SolidsRead( << 2775 { 3881 const xercesc::DOMElement* const solidsElem << 2776 if ((*surfaceList)[i]->GetName() == ref) { return (*surfaceList)[i]; } 3882 { << 2777 } 3883 #ifdef G4VERBOSE << 3884 G4cout << "G4GDML: Reading solids..." << G4 << 3885 #endif << 3886 for(xercesc::DOMNode* iter = solidsElement- << 3887 iter = iter->getNextS << 3888 { << 3889 if(iter->getNodeType() != xercesc::DOMNod << 3890 { << 3891 continue; << 3892 } << 3893 << 3894 const xercesc::DOMElement* const child = << 3895 dynamic_cast<xercesc::DOMElement*>(iter << 3896 if(child == nullptr) << 3897 { << 3898 G4Exception("G4GDMLReadSolids::SolidsRe << 3899 FatalException, "No child f << 3900 return; << 3901 } << 3902 const G4String tag = Transcode(child->get << 3903 if(tag == "define") << 3904 { << 3905 DefineRead(child); << 3906 } << 3907 else if(tag == "box") << 3908 { << 3909 BoxRead(child); << 3910 } << 3911 else if(tag == "cone") << 3912 { << 3913 ConeRead(child); << 3914 } << 3915 else if(tag == "elcone") << 3916 { << 3917 ElconeRead(child); << 3918 } << 3919 else if(tag == "ellipsoid") << 3920 { << 3921 EllipsoidRead(child); << 3922 } << 3923 else if(tag == "eltube") << 3924 { << 3925 EltubeRead(child); << 3926 } << 3927 else if(tag == "xtru") << 3928 { << 3929 XtruRead(child); << 3930 } << 3931 else if(tag == "hype") << 3932 { << 3933 HypeRead(child); << 3934 } << 3935 else if(tag == "intersection") << 3936 { << 3937 BooleanRead(child, INTERSECTION); << 3938 } << 3939 else if(tag == "multiUnion") << 3940 { << 3941 MultiUnionRead(child); << 3942 } << 3943 else if(tag == "orb") << 3944 { << 3945 OrbRead(child); << 3946 } << 3947 else if(tag == "para") << 3948 { << 3949 ParaRead(child); << 3950 } << 3951 else if(tag == "paraboloid") << 3952 { << 3953 ParaboloidRead(child); << 3954 } << 3955 else if(tag == "polycone") << 3956 { << 3957 PolyconeRead(child); << 3958 } << 3959 else if(tag == "genericPolycone") << 3960 { << 3961 GenericPolyconeRead(child); << 3962 } << 3963 else if(tag == "polyhedra") << 3964 { << 3965 PolyhedraRead(child); << 3966 } << 3967 else if(tag == "genericPolyhedra") << 3968 { << 3969 GenericPolyhedraRead(child); << 3970 } << 3971 else if(tag == "reflectedSolid") << 3972 { << 3973 ReflectedSolidRead(child); << 3974 } << 3975 else if(tag == "scaledSolid") << 3976 { << 3977 ScaledSolidRead(child); << 3978 } << 3979 else if(tag == "sphere") << 3980 { << 3981 SphereRead(child); << 3982 } << 3983 else if(tag == "subtraction") << 3984 { << 3985 BooleanRead(child, SUBTRACTION); << 3986 } << 3987 else if(tag == "tessellated") << 3988 { << 3989 TessellatedRead(child); << 3990 } << 3991 else if(tag == "tet") << 3992 { << 3993 TetRead(child); << 3994 } << 3995 else if(tag == "torus") << 3996 { << 3997 TorusRead(child); << 3998 } << 3999 else if(tag == "arb8") << 4000 { << 4001 GenTrapRead(child); << 4002 } << 4003 else if(tag == "trap") << 4004 { << 4005 TrapRead(child); << 4006 } << 4007 else if(tag == "trd") << 4008 { << 4009 TrdRead(child); << 4010 } << 4011 else if(tag == "tube") << 4012 { << 4013 TubeRead(child); << 4014 } << 4015 else if(tag == "cutTube") << 4016 { << 4017 CutTubeRead(child); << 4018 } << 4019 else if(tag == "twistedbox") << 4020 { << 4021 TwistedboxRead(child); << 4022 } << 4023 else if(tag == "twistedtrap") << 4024 { << 4025 TwistedtrapRead(child); << 4026 } << 4027 else if(tag == "twistedtrd") << 4028 { << 4029 TwistedtrdRead(child); << 4030 } << 4031 else if(tag == "twistedtubs") << 4032 { << 4033 TwistedtubsRead(child); << 4034 } << 4035 else if(tag == "union") << 4036 { << 4037 BooleanRead(child, UNION); << 4038 } << 4039 else if(tag == "opticalsurface") << 4040 { << 4041 OpticalSurfaceRead(child); << 4042 } << 4043 else if(tag == "loop") << 4044 { << 4045 LoopRead(child, &G4GDMLRead::SolidsRead << 4046 } << 4047 else << 4048 { << 4049 G4String error_msg = "Unknown tag in so << 4050 G4Exception("G4GDMLReadSolids::SolidsRe << 4051 error_msg); << 4052 } << 4053 } << 4054 } << 4055 << 4056 // ------------------------------------------ << 4057 G4VSolid* G4GDMLReadSolids::GetSolid(const G4 << 4058 { << 4059 G4VSolid* solidPtr = G4SolidStore::GetInsta << 4060 ->GetSoli << 4061 2778 4062 if(solidPtr == nullptr) << 2779 G4String error_msg = "Referenced optical surface '" + ref + "' was not found!"; 4063 { << 2780 G4Exception("G4GDMLReadSolids::GetSurfaceProperty()", "ReadError", 4064 G4String error_msg = "Referenced solid '" << 2781 FatalException, error_msg); 4065 G4Exception("G4GDMLReadSolids::GetSolid() << 4066 error_msg); << 4067 } << 4068 << 4069 return solidPtr; << 4070 } << 4071 << 4072 // ------------------------------------------ << 4073 G4SurfaceProperty* G4GDMLReadSolids::GetSurfa << 4074 const G4String& ref) const << 4075 { << 4076 const G4SurfacePropertyTable* surfaceList = << 4077 G4SurfaceProperty::GetSurfacePropertyTabl << 4078 const std::size_t surfaceCount = surfaceLis << 4079 << 4080 for(std::size_t i = 0; i < surfaceCount; ++ << 4081 { << 4082 if((*surfaceList)[i]->GetName() == ref) << 4083 { << 4084 return (*surfaceList)[i]; << 4085 } << 4086 } << 4087 << 4088 G4String error_msg = << 4089 "Referenced optical surface '" + ref + "' << 4090 G4Exception("G4GDMLReadSolids::GetSurfacePr << 4091 FatalException, error_msg); << 4092 2782 4093 return nullptr; << 2783 return 0; 4094 } 2784 } 4095 2785