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