| 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 // G4GDMLParamVol implementation <<
27 // 26 //
28 // Author: Zoltan Torzsok, November 2007 << 27 // $Id: G4GDMLWriteParamvol.cc,v 1.25 2009/04/24 15:34:20 gcosmo Exp $
>> 28 // GEANT4 tag $Name: geant4-09-03 $
>> 29 //
>> 30 // class G4GDMLParamVol Implementation
>> 31 //
>> 32 // Original author: Zoltan Torzsok, November 2007
>> 33 //
29 // ------------------------------------------- 34 // --------------------------------------------------------------------
30 35
31 #include "G4GDMLWriteParamvol.hh" 36 #include "G4GDMLWriteParamvol.hh"
32 #include "G4GDMLWriteSolids.hh" <<
33 37
34 #include "G4SystemOfUnits.hh" <<
35 #include "G4Box.hh" 38 #include "G4Box.hh"
36 #include "G4Trd.hh" 39 #include "G4Trd.hh"
37 #include "G4Trap.hh" 40 #include "G4Trap.hh"
38 #include "G4Tubs.hh" 41 #include "G4Tubs.hh"
39 #include "G4Cons.hh" 42 #include "G4Cons.hh"
40 #include "G4Sphere.hh" 43 #include "G4Sphere.hh"
41 #include "G4Orb.hh" 44 #include "G4Orb.hh"
42 #include "G4Torus.hh" 45 #include "G4Torus.hh"
43 #include "G4Ellipsoid.hh" <<
44 #include "G4Para.hh" 46 #include "G4Para.hh"
45 #include "G4Hype.hh" 47 #include "G4Hype.hh"
46 #include "G4Polycone.hh" <<
47 #include "G4Polyhedra.hh" <<
48 #include "G4LogicalVolume.hh" 48 #include "G4LogicalVolume.hh"
49 #include "G4VPhysicalVolume.hh" 49 #include "G4VPhysicalVolume.hh"
50 #include "G4PVParameterised.hh" 50 #include "G4PVParameterised.hh"
51 #include "G4VPVParameterisation.hh" 51 #include "G4VPVParameterisation.hh"
52 52
53 // ------------------------------------------- << 53 G4GDMLWriteParamvol::
54 G4GDMLWriteParamvol::G4GDMLWriteParamvol() << 54 G4GDMLWriteParamvol() : G4GDMLWriteSetup()
55 : G4GDMLWriteSetup() <<
56 { <<
57 } <<
58 <<
59 // ------------------------------------------- <<
60 G4GDMLWriteParamvol::~G4GDMLWriteParamvol() <<
61 { <<
62 } <<
63 <<
64 // ------------------------------------------- <<
65 void G4GDMLWriteParamvol::Box_dimensionsWrite( <<
66 xercesc::DOMElement* parametersElement, cons <<
67 { <<
68 xercesc::DOMElement* box_dimensionsElement = <<
69 box_dimensionsElement->setAttributeNode( <<
70 NewAttribute("x", 2.0 * box->GetXHalfLengt <<
71 box_dimensionsElement->setAttributeNode( <<
72 NewAttribute("y", 2.0 * box->GetYHalfLengt <<
73 box_dimensionsElement->setAttributeNode( <<
74 NewAttribute("z", 2.0 * box->GetZHalfLengt <<
75 box_dimensionsElement->setAttributeNode(NewA <<
76 parametersElement->appendChild(box_dimension <<
77 } <<
78 <<
79 // ------------------------------------------- <<
80 void G4GDMLWriteParamvol::Trd_dimensionsWrite( <<
81 xercesc::DOMElement* parametersElement, cons <<
82 { <<
83 xercesc::DOMElement* trd_dimensionsElement = <<
84 trd_dimensionsElement->setAttributeNode( <<
85 NewAttribute("x1", 2.0 * trd->GetXHalfLeng <<
86 trd_dimensionsElement->setAttributeNode( <<
87 NewAttribute("x2", 2.0 * trd->GetXHalfLeng <<
88 trd_dimensionsElement->setAttributeNode( <<
89 NewAttribute("y1", 2.0 * trd->GetYHalfLeng <<
90 trd_dimensionsElement->setAttributeNode( <<
91 NewAttribute("y2", 2.0 * trd->GetYHalfLeng <<
92 trd_dimensionsElement->setAttributeNode( <<
93 NewAttribute("z", 2.0 * trd->GetZHalfLengt <<
94 trd_dimensionsElement->setAttributeNode(NewA <<
95 parametersElement->appendChild(trd_dimension <<
96 } <<
97 <<
98 // ------------------------------------------- <<
99 void G4GDMLWriteParamvol::Trap_dimensionsWrite <<
100 xercesc::DOMElement* parametersElement, cons <<
101 { <<
102 const G4ThreeVector simaxis = trap->GetSymAx <<
103 const G4double phi = <<
104 (simaxis.z() != 1.0) ? (std::atan(simaxis. <<
105 const G4double theta = std::acos(simaxis.z( <<
106 const G4double alpha1 = std::atan(trap->GetT <<
107 const G4double alpha2 = std::atan(trap->GetT <<
108 <<
109 xercesc::DOMElement* trap_dimensionsElement <<
110 trap_dimensionsElement->setAttributeNode( <<
111 NewAttribute("z", 2.0 * trap->GetZHalfLeng <<
112 trap_dimensionsElement->setAttributeNode( <<
113 NewAttribute("theta", theta / degree)); <<
114 trap_dimensionsElement->setAttributeNode(New <<
115 trap_dimensionsElement->setAttributeNode( <<
116 NewAttribute("y1", 2.0 * trap->GetYHalfLen <<
117 trap_dimensionsElement->setAttributeNode( <<
118 NewAttribute("x1", 2.0 * trap->GetXHalfLen <<
119 trap_dimensionsElement->setAttributeNode( <<
120 NewAttribute("x2", 2.0 * trap->GetXHalfLen <<
121 trap_dimensionsElement->setAttributeNode( <<
122 NewAttribute("alpha1", alpha1 / degree)); <<
123 trap_dimensionsElement->setAttributeNode( <<
124 NewAttribute("y2", 2.0 * trap->GetYHalfLen <<
125 trap_dimensionsElement->setAttributeNode( <<
126 NewAttribute("x3", 2.0 * trap->GetXHalfLen <<
127 trap_dimensionsElement->setAttributeNode( <<
128 NewAttribute("x4", 2.0 * trap->GetXHalfLen <<
129 trap_dimensionsElement->setAttributeNode( <<
130 NewAttribute("alpha2", alpha2 / degree)); <<
131 trap_dimensionsElement->setAttributeNode(New <<
132 trap_dimensionsElement->setAttributeNode(New <<
133 parametersElement->appendChild(trap_dimensio <<
134 } <<
135 <<
136 // ------------------------------------------- <<
137 void G4GDMLWriteParamvol::Tube_dimensionsWrite <<
138 xercesc::DOMElement* parametersElement, cons <<
139 { <<
140 xercesc::DOMElement* tube_dimensionsElement <<
141 tube_dimensionsElement->setAttributeNode( <<
142 NewAttribute("InR", tube->GetInnerRadius() <<
143 tube_dimensionsElement->setAttributeNode( <<
144 NewAttribute("OutR", tube->GetOuterRadius( <<
145 tube_dimensionsElement->setAttributeNode( <<
146 NewAttribute("hz", 2.0 * tube->GetZHalfLen <<
147 tube_dimensionsElement->setAttributeNode( <<
148 NewAttribute("StartPhi", tube->GetStartPhi <<
149 tube_dimensionsElement->setAttributeNode( <<
150 NewAttribute("DeltaPhi", tube->GetDeltaPhi <<
151 tube_dimensionsElement->setAttributeNode(New <<
152 tube_dimensionsElement->setAttributeNode(New <<
153 parametersElement->appendChild(tube_dimensio <<
154 } <<
155 <<
156 // ------------------------------------------- <<
157 void G4GDMLWriteParamvol::Cone_dimensionsWrite <<
158 xercesc::DOMElement* parametersElement, cons <<
159 { <<
160 xercesc::DOMElement* cone_dimensionsElement <<
161 cone_dimensionsElement->setAttributeNode( <<
162 NewAttribute("rmin1", cone->GetInnerRadius <<
163 cone_dimensionsElement->setAttributeNode( <<
164 NewAttribute("rmax1", cone->GetOuterRadius <<
165 cone_dimensionsElement->setAttributeNode( <<
166 NewAttribute("rmin2", cone->GetInnerRadius <<
167 cone_dimensionsElement->setAttributeNode( <<
168 NewAttribute("rmax2", cone->GetOuterRadius <<
169 cone_dimensionsElement->setAttributeNode( <<
170 NewAttribute("z", 2.0 * cone->GetZHalfLeng <<
171 cone_dimensionsElement->setAttributeNode( <<
172 NewAttribute("startphi", cone->GetStartPhi <<
173 cone_dimensionsElement->setAttributeNode( <<
174 NewAttribute("deltaphi", cone->GetDeltaPhi <<
175 cone_dimensionsElement->setAttributeNode(New <<
176 cone_dimensionsElement->setAttributeNode(New <<
177 parametersElement->appendChild(cone_dimensio <<
178 } <<
179 <<
180 // ------------------------------------------- <<
181 void G4GDMLWriteParamvol::Sphere_dimensionsWri <<
182 xercesc::DOMElement* parametersElement, cons <<
183 { <<
184 xercesc::DOMElement* sphere_dimensionsElemen <<
185 NewElement("sphere_dimensions"); <<
186 sphere_dimensionsElement->setAttributeNode( <<
187 NewAttribute("rmin", sphere->GetInnerRadiu <<
188 sphere_dimensionsElement->setAttributeNode( <<
189 NewAttribute("rmax", sphere->GetOuterRadiu <<
190 sphere_dimensionsElement->setAttributeNode( <<
191 NewAttribute("startphi", sphere->GetStartP <<
192 sphere_dimensionsElement->setAttributeNode( <<
193 NewAttribute("deltaphi", sphere->GetDeltaP <<
194 sphere_dimensionsElement->setAttributeNode( <<
195 NewAttribute("starttheta", sphere->GetStar <<
196 sphere_dimensionsElement->setAttributeNode( <<
197 NewAttribute("deltatheta", sphere->GetDelt <<
198 sphere_dimensionsElement->setAttributeNode(N <<
199 sphere_dimensionsElement->setAttributeNode(N <<
200 parametersElement->appendChild(sphere_dimens <<
201 } <<
202 <<
203 // ------------------------------------------- <<
204 void G4GDMLWriteParamvol::Orb_dimensionsWrite( <<
205 xercesc::DOMElement* parametersElement, cons <<
206 { <<
207 xercesc::DOMElement* orb_dimensionsElement = <<
208 orb_dimensionsElement->setAttributeNode( <<
209 NewAttribute("r", orb->GetRadius() / mm)); <<
210 orb_dimensionsElement->setAttributeNode(NewA <<
211 parametersElement->appendChild(orb_dimension <<
212 } <<
213 <<
214 // ------------------------------------------- <<
215 void G4GDMLWriteParamvol::Torus_dimensionsWrit <<
216 xercesc::DOMElement* parametersElement, cons <<
217 { <<
218 xercesc::DOMElement* torus_dimensionsElement <<
219 torus_dimensionsElement->setAttributeNode( <<
220 NewAttribute("rmin", torus->GetRmin() / mm <<
221 torus_dimensionsElement->setAttributeNode( <<
222 NewAttribute("rmax", torus->GetRmax() / mm <<
223 torus_dimensionsElement->setAttributeNode( <<
224 NewAttribute("rtor", torus->GetRtor() / mm <<
225 torus_dimensionsElement->setAttributeNode( <<
226 NewAttribute("startphi", torus->GetSPhi() <<
227 torus_dimensionsElement->setAttributeNode( <<
228 NewAttribute("deltaphi", torus->GetDPhi() <<
229 torus_dimensionsElement->setAttributeNode(Ne <<
230 torus_dimensionsElement->setAttributeNode(Ne <<
231 parametersElement->appendChild(torus_dimensi <<
232 } <<
233 <<
234 // ------------------------------------------- <<
235 void G4GDMLWriteParamvol::Ellipsoid_dimensions <<
236 xercesc::DOMElement* parametersElement, cons <<
237 { <<
238 xercesc::DOMElement* ellipsoid_dimensionsEle <<
239 NewElement("ellipsoid_dimensions"); <<
240 ellipsoid_dimensionsElement->setAttributeNod <<
241 NewAttribute("ax", ellipsoid->GetSemiAxisM <<
242 ellipsoid_dimensionsElement->setAttributeNod <<
243 NewAttribute("by", ellipsoid->GetSemiAxisM <<
244 ellipsoid_dimensionsElement->setAttributeNod <<
245 NewAttribute("cz", ellipsoid->GetSemiAxisM <<
246 ellipsoid_dimensionsElement->setAttributeNod <<
247 NewAttribute("zcut1", ellipsoid->GetZBotto <<
248 ellipsoid_dimensionsElement->setAttributeNod <<
249 NewAttribute("zcut2", ellipsoid->GetZTopCu <<
250 ellipsoid_dimensionsElement->setAttributeNod <<
251 parametersElement->appendChild(ellipsoid_dim <<
252 } <<
253 <<
254 // ------------------------------------------- <<
255 void G4GDMLWriteParamvol::Para_dimensionsWrite <<
256 xercesc::DOMElement* parametersElement, cons <<
257 { <<
258 const G4ThreeVector simaxis = para->GetSymAx <<
259 <<
260 const G4double alpha = std::atan(para->GetTa <<
261 const G4double theta = std::acos(simaxis.z() <<
262 const G4double phi = <<
263 (simaxis.z() != 1.0) ? (std::atan(simaxis. <<
264 <<
265 xercesc::DOMElement* para_dimensionsElement <<
266 para_dimensionsElement->setAttributeNode( <<
267 NewAttribute("x", 2.0 * para->GetXHalfLeng <<
268 para_dimensionsElement->setAttributeNode( <<
269 NewAttribute("y", 2.0 * para->GetYHalfLeng <<
270 para_dimensionsElement->setAttributeNode( <<
271 NewAttribute("z", 2.0 * para->GetZHalfLeng <<
272 para_dimensionsElement->setAttributeNode( <<
273 NewAttribute("alpha", alpha / degree)); <<
274 para_dimensionsElement->setAttributeNode( <<
275 NewAttribute("theta", theta / degree)); <<
276 para_dimensionsElement->setAttributeNode(New <<
277 para_dimensionsElement->setAttributeNode(New <<
278 para_dimensionsElement->setAttributeNode(New <<
279 parametersElement->appendChild(para_dimensio <<
280 } <<
281 <<
282 // ------------------------------------------- <<
283 void G4GDMLWriteParamvol::Hype_dimensionsWrite <<
284 xercesc::DOMElement* parametersElement, cons <<
285 { <<
286 xercesc::DOMElement* hype_dimensionsElement <<
287 hype_dimensionsElement->setAttributeNode( <<
288 NewAttribute("rmin", hype->GetInnerRadius( <<
289 hype_dimensionsElement->setAttributeNode( <<
290 NewAttribute("rmax", hype->GetOuterRadius( <<
291 hype_dimensionsElement->setAttributeNode( <<
292 NewAttribute("inst", hype->GetInnerStereo( <<
293 hype_dimensionsElement->setAttributeNode( <<
294 NewAttribute("outst", hype->GetOuterStereo <<
295 hype_dimensionsElement->setAttributeNode( <<
296 NewAttribute("z", 2.0 * hype->GetZHalfLeng <<
297 hype_dimensionsElement->setAttributeNode(New <<
298 hype_dimensionsElement->setAttributeNode(New <<
299 parametersElement->appendChild(hype_dimensio <<
300 } <<
301 <<
302 // ------------------------------------------- <<
303 void G4GDMLWriteParamvol::Polycone_dimensionsW <<
304 xercesc::DOMElement* parametersElement, cons <<
305 { <<
306 xercesc::DOMElement* pcone_dimensionsElement <<
307 NewElement("polycone_dimensions"); <<
308 <<
309 pcone_dimensionsElement->setAttributeNode( <<
310 NewAttribute("numRZ", pcone->GetOriginalPa <<
311 pcone_dimensionsElement->setAttributeNode(Ne <<
312 "startPhi", pcone->GetOriginalParameters() <<
313 pcone_dimensionsElement->setAttributeNode(Ne <<
314 "openPhi", pcone->GetOriginalParameters()- <<
315 pcone_dimensionsElement->setAttributeNode(Ne <<
316 pcone_dimensionsElement->setAttributeNode(Ne <<
317 <<
318 parametersElement->appendChild(pcone_dimensi <<
319 const size_t num_zplanes = pcone->GetOrigi <<
320 const G4double* z_array = pcone->GetOrigi <<
321 const G4double* rmin_array = pcone->GetOrigi <<
322 const G4double* rmax_array = pcone->GetOrigi <<
323 <<
324 for(std::size_t i = 0; i < num_zplanes; ++i) <<
325 { <<
326 ZplaneWrite(pcone_dimensionsElement, z_arr <<
327 rmax_array[i]); <<
328 } <<
329 } <<
330 <<
331 // ------------------------------------------- <<
332 void G4GDMLWriteParamvol::Polyhedra_dimensions <<
333 xercesc::DOMElement* parametersElement, cons <<
334 { <<
335 xercesc::DOMElement* polyhedra_dimensionsEle <<
336 NewElement("polyhedra_dimensions"); <<
337 <<
338 polyhedra_dimensionsElement->setAttributeNod <<
339 NewAttribute("numRZ", polyhedra->GetOrigin <<
340 polyhedra_dimensionsElement->setAttributeNod <<
341 NewAttribute("numSide", polyhedra->GetOrig <<
342 polyhedra_dimensionsElement->setAttributeNod <<
343 "startPhi", polyhedra->GetOriginalParamete <<
344 polyhedra_dimensionsElement->setAttributeNod <<
345 "openPhi", polyhedra->GetOriginalParameter <<
346 polyhedra_dimensionsElement->setAttributeNod <<
347 polyhedra_dimensionsElement->setAttributeNod <<
348 <<
349 parametersElement->appendChild(polyhedra_dim <<
350 const size_t num_zplanes = polyhedra->GetO <<
351 const G4double* z_array = polyhedra->GetO <<
352 const G4double* rmin_array = polyhedra->GetO <<
353 const G4double* rmax_array = polyhedra->GetO <<
354 <<
355 for(std::size_t i = 0; i < num_zplanes; ++i) <<
356 { <<
357 ZplaneWrite(polyhedra_dimensionsElement, z <<
358 rmax_array[i]); <<
359 } <<
360 } <<
361 <<
362 // ------------------------------------------- <<
363 void G4GDMLWriteParamvol::ParametersWrite(xerc <<
364 const G4VPhysicalVolume* co <<
365 { 55 {
366 paramvol->GetParameterisation()->ComputeTran <<
367 index, const_cast<G4VPhysicalVolume*>(para <<
368 G4ThreeVector Angles; <<
369 G4String name = GenerateName(paramvol->GetNa <<
370 std::stringstream os; <<
371 os.precision(15); <<
372 os << index; <<
373 G4String sncopie = os.str(); <<
374 <<
375 xercesc::DOMElement* parametersElement = New <<
376 parametersElement->setAttributeNode(NewAttri <<
377 <<
378 PositionWrite(parametersElement, name + snco <<
379 paramvol->GetObjectTranslation <<
380 Angles = GetAngles(paramvol->GetObjectRotati <<
381 if(Angles.mag2() > DBL_EPSILON) <<
382 { <<
383 RotationWrite(parametersElement, name + sn <<
384 GetAngles(paramvol->GetObjec <<
385 } <<
386 paramvolElement->appendChild(parametersEleme <<
387 <<
388 G4VSolid* solid = paramvol->GetLogicalVolume <<
389 <<
390 if(G4Box* box = dynamic_cast<G4Box*>(solid)) <<
391 { <<
392 paramvol->GetParameterisation()->ComputeDi <<
393 *box, index, const_cast<G4VPhysicalVolum <<
394 Box_dimensionsWrite(parametersElement, box <<
395 } <<
396 else if(G4Trd* trd = dynamic_cast<G4Trd*>(so <<
397 { <<
398 paramvol->GetParameterisation()->ComputeDi <<
399 *trd, index, const_cast<G4VPhysicalVolum <<
400 Trd_dimensionsWrite(parametersElement, trd <<
401 } <<
402 else if(G4Trap* trap = dynamic_cast<G4Trap*> <<
403 { <<
404 paramvol->GetParameterisation()->ComputeDi <<
405 *trap, index, const_cast<G4VPhysicalVolu <<
406 Trap_dimensionsWrite(parametersElement, tr <<
407 } <<
408 else if(G4Tubs* tube = dynamic_cast<G4Tubs*> <<
409 { <<
410 paramvol->GetParameterisation()->ComputeDi <<
411 *tube, index, const_cast<G4VPhysicalVolu <<
412 Tube_dimensionsWrite(parametersElement, tu <<
413 } <<
414 else if(G4Cons* cone = dynamic_cast<G4Cons*> <<
415 { <<
416 paramvol->GetParameterisation()->ComputeDi <<
417 *cone, index, const_cast<G4VPhysicalVolu <<
418 Cone_dimensionsWrite(parametersElement, co <<
419 } <<
420 else if(G4Sphere* sphere = dynamic_cast<G4Sp <<
421 { <<
422 paramvol->GetParameterisation()->ComputeDi <<
423 *sphere, index, const_cast<G4VPhysicalVo <<
424 Sphere_dimensionsWrite(parametersElement, <<
425 } <<
426 else if(G4Orb* orb = dynamic_cast<G4Orb*>(so <<
427 { <<
428 paramvol->GetParameterisation()->ComputeDi <<
429 *orb, index, const_cast<G4VPhysicalVolum <<
430 Orb_dimensionsWrite(parametersElement, orb <<
431 } <<
432 else if(G4Torus* torus = dynamic_cast<G4Toru <<
433 { <<
434 paramvol->GetParameterisation()->ComputeDi <<
435 *torus, index, const_cast<G4VPhysicalVol <<
436 Torus_dimensionsWrite(parametersElement, t <<
437 } <<
438 else if(G4Ellipsoid* ellipsoid = dynamic_cas <<
439 { <<
440 paramvol->GetParameterisation()->ComputeDi <<
441 *ellipsoid, index, const_cast<G4VPhysica <<
442 Ellipsoid_dimensionsWrite(parametersElemen <<
443 } <<
444 else if(G4Para* para = dynamic_cast<G4Para*> <<
445 { <<
446 paramvol->GetParameterisation()->ComputeDi <<
447 *para, index, const_cast<G4VPhysicalVolu <<
448 Para_dimensionsWrite(parametersElement, pa <<
449 } <<
450 else if(G4Hype* hype = dynamic_cast<G4Hype*> <<
451 { <<
452 paramvol->GetParameterisation()->ComputeDi <<
453 *hype, index, const_cast<G4VPhysicalVolu <<
454 Hype_dimensionsWrite(parametersElement, hy <<
455 } <<
456 else if(G4Polycone* pcone = dynamic_cast<G4P <<
457 { <<
458 paramvol->GetParameterisation()->ComputeDi <<
459 *pcone, index, const_cast<G4VPhysicalVol <<
460 Polycone_dimensionsWrite(parametersElement <<
461 } <<
462 else if(G4Polyhedra* polyhedra = dynamic_cas <<
463 { <<
464 paramvol->GetParameterisation()->ComputeDi <<
465 *polyhedra, index, const_cast<G4VPhysica <<
466 Polyhedra_dimensionsWrite(parametersElemen <<
467 } <<
468 else <<
469 { <<
470 G4String error_msg = "Solid '" + solid->Ge <<
471 "' cannot be used in <<
472 G4Exception("G4GDMLWriteParamvol::Paramete <<
473 FatalException, error_msg); <<
474 } <<
475 } 56 }
476 57
477 // ------------------------------------------- << 58 G4GDMLWriteParamvol::
478 void G4GDMLWriteParamvol::ParamvolWrite(xerces << 59 ~G4GDMLWriteParamvol()
479 const <<
480 { 60 {
481 const G4String volumeref = GenerateName( <<
482 paramvol->GetLogicalVolume()->GetName(), p <<
483 xercesc::DOMElement* paramvolElement = NewEl <<
484 paramvolElement->setAttributeNode( <<
485 NewAttribute("ncopies", paramvol->GetMulti <<
486 xercesc::DOMElement* volumerefElement = NewE <<
487 volumerefElement->setAttributeNode(NewAttrib <<
488 <<
489 xercesc::DOMElement* algorithmElement = <<
490 NewElement("parameterised_position_size"); <<
491 paramvolElement->appendChild(volumerefElemen <<
492 paramvolElement->appendChild(algorithmElemen <<
493 ParamvolAlgorithmWrite(algorithmElement, par <<
494 volumeElement->appendChild(paramvolElement); <<
495 } 61 }
496 62
497 // ------------------------------------------- << 63 void G4GDMLWriteParamvol::
498 void G4GDMLWriteParamvol::ParamvolAlgorithmWri << 64 Box_dimensionsWrite(xercesc::DOMElement* parametersElement,
499 xercesc::DOMElement* paramvolElement, const << 65 const G4Box* const box)
500 { << 66 {
501 const G4String volumeref = GenerateName( << 67 xercesc::DOMElement* box_dimensionsElement = NewElement("box_dimensions");
502 paramvol->GetLogicalVolume()->GetName(), p << 68 box_dimensionsElement->
503 << 69 setAttributeNode(NewAttribute("x",2.0*box->GetXHalfLength()/mm));
504 const G4int parameterCount = paramvol->GetMu << 70 box_dimensionsElement->
505 << 71 setAttributeNode(NewAttribute("y",2.0*box->GetYHalfLength()/mm));
506 for(G4int i = 0; i < parameterCount; ++i) << 72 box_dimensionsElement->
507 { << 73 setAttributeNode(NewAttribute("z",2.0*box->GetZHalfLength()/mm));
508 ParametersWrite(paramvolElement, paramvol, << 74 box_dimensionsElement->
509 } << 75 setAttributeNode(NewAttribute("lunit","mm"));
>> 76 parametersElement->appendChild(box_dimensionsElement);
>> 77 }
>> 78
>> 79 void G4GDMLWriteParamvol::
>> 80 Trd_dimensionsWrite(xercesc::DOMElement* parametersElement,
>> 81 const G4Trd* const trd)
>> 82 {
>> 83 xercesc::DOMElement* trd_dimensionsElement = NewElement("trd_dimensions");
>> 84 trd_dimensionsElement->
>> 85 setAttributeNode(NewAttribute("x1",2.0*trd->GetXHalfLength1()/mm));
>> 86 trd_dimensionsElement->
>> 87 setAttributeNode(NewAttribute("x2",2.0*trd->GetXHalfLength2()/mm));
>> 88 trd_dimensionsElement->
>> 89 setAttributeNode(NewAttribute("y1",2.0*trd->GetYHalfLength1()/mm));
>> 90 trd_dimensionsElement->
>> 91 setAttributeNode(NewAttribute("y2",2.0*trd->GetYHalfLength2()/mm));
>> 92 trd_dimensionsElement->
>> 93 setAttributeNode(NewAttribute("z",2.0*trd->GetZHalfLength()/mm));
>> 94 trd_dimensionsElement->
>> 95 setAttributeNode(NewAttribute("lunit","mm"));
>> 96 parametersElement->appendChild(trd_dimensionsElement);
>> 97 }
>> 98
>> 99 void G4GDMLWriteParamvol::
>> 100 Trap_dimensionsWrite(xercesc::DOMElement* parametersElement,
>> 101 const G4Trap* const trap)
>> 102 {
>> 103 const G4ThreeVector simaxis = trap->GetSymAxis();
>> 104 const G4double phi = (simaxis.z() != 1.0)
>> 105 ? (std::atan(simaxis.y()/simaxis.x())) : (0.0);
>> 106 const G4double theta = std::acos(simaxis.z());
>> 107 const G4double alpha1 = std::atan(trap->GetTanAlpha1());
>> 108 const G4double alpha2 = std::atan(trap->GetTanAlpha2());
>> 109
>> 110 xercesc::DOMElement* trap_dimensionsElement = NewElement("trap");
>> 111 trap_dimensionsElement->
>> 112 setAttributeNode(NewAttribute("z",2.0*trap->GetZHalfLength()/mm));
>> 113 trap_dimensionsElement->
>> 114 setAttributeNode(NewAttribute("theta",theta/degree));
>> 115 trap_dimensionsElement->
>> 116 setAttributeNode(NewAttribute("phi",phi/degree));
>> 117 trap_dimensionsElement->
>> 118 setAttributeNode(NewAttribute("y1",2.0*trap->GetYHalfLength1()/mm));
>> 119 trap_dimensionsElement->
>> 120 setAttributeNode(NewAttribute("x1",2.0*trap->GetXHalfLength1()/mm));
>> 121 trap_dimensionsElement->
>> 122 setAttributeNode(NewAttribute("x2",2.0*trap->GetXHalfLength2()/mm));
>> 123 trap_dimensionsElement->
>> 124 setAttributeNode(NewAttribute("alpha1",alpha1/degree));
>> 125 trap_dimensionsElement->
>> 126 setAttributeNode(NewAttribute("y2",2.0*trap->GetYHalfLength2()/mm));
>> 127 trap_dimensionsElement->
>> 128 setAttributeNode(NewAttribute("x3",2.0*trap->GetXHalfLength3()/mm));
>> 129 trap_dimensionsElement->
>> 130 setAttributeNode(NewAttribute("x4",2.0*trap->GetXHalfLength4()/mm));
>> 131 trap_dimensionsElement->
>> 132 setAttributeNode(NewAttribute("alpha2",alpha2/degree));
>> 133 trap_dimensionsElement->
>> 134 setAttributeNode(NewAttribute("aunit","deg"));
>> 135 trap_dimensionsElement->
>> 136 setAttributeNode(NewAttribute("lunit","mm"));
>> 137 parametersElement->appendChild(trap_dimensionsElement);
>> 138 }
>> 139
>> 140 void G4GDMLWriteParamvol::
>> 141 Tube_dimensionsWrite(xercesc::DOMElement* parametersElement,
>> 142 const G4Tubs* const tube)
>> 143 {
>> 144 xercesc::DOMElement* tube_dimensionsElement = NewElement("tube_dimensions");
>> 145 tube_dimensionsElement->
>> 146 setAttributeNode(NewAttribute("InR",tube->GetInnerRadius()/mm));
>> 147 tube_dimensionsElement->
>> 148 setAttributeNode(NewAttribute("OutR",tube->GetOuterRadius()/mm));
>> 149 tube_dimensionsElement->
>> 150 setAttributeNode(NewAttribute("hz",2.0*tube->GetZHalfLength()/mm));
>> 151 tube_dimensionsElement->
>> 152 setAttributeNode(NewAttribute("StartPhi",tube->GetStartPhiAngle()/degree));
>> 153 tube_dimensionsElement->
>> 154 setAttributeNode(NewAttribute("DeltaPhi",tube->GetDeltaPhiAngle()/degree));
>> 155 tube_dimensionsElement->
>> 156 setAttributeNode(NewAttribute("aunit","deg"));
>> 157 tube_dimensionsElement->
>> 158 setAttributeNode(NewAttribute("lunit","mm"));
>> 159 parametersElement->appendChild(tube_dimensionsElement);
>> 160 }
>> 161
>> 162
>> 163 void G4GDMLWriteParamvol::
>> 164 Cone_dimensionsWrite(xercesc::DOMElement* parametersElement,
>> 165 const G4Cons* const cone)
>> 166 {
>> 167 xercesc::DOMElement* cone_dimensionsElement = NewElement("cone_dimensions");
>> 168 cone_dimensionsElement->
>> 169 setAttributeNode(NewAttribute("rmin1",cone->GetInnerRadiusMinusZ()/mm));
>> 170 cone_dimensionsElement->
>> 171 setAttributeNode(NewAttribute("rmax1",cone->GetOuterRadiusMinusZ()/mm));
>> 172 cone_dimensionsElement->
>> 173 setAttributeNode(NewAttribute("rmin2",cone->GetInnerRadiusPlusZ()/mm));
>> 174 cone_dimensionsElement->
>> 175 setAttributeNode(NewAttribute("rmax2",cone->GetOuterRadiusPlusZ()/mm));
>> 176 cone_dimensionsElement->
>> 177 setAttributeNode(NewAttribute("z",2.0*cone->GetZHalfLength()/mm));
>> 178 cone_dimensionsElement->
>> 179 setAttributeNode(NewAttribute("startphi",cone->GetStartPhiAngle()/degree));
>> 180 cone_dimensionsElement->
>> 181 setAttributeNode(NewAttribute("deltaphi",cone->GetDeltaPhiAngle()/degree));
>> 182 cone_dimensionsElement->
>> 183 setAttributeNode(NewAttribute("aunit","deg"));
>> 184 cone_dimensionsElement->
>> 185 setAttributeNode(NewAttribute("lunit","mm"));
>> 186 parametersElement->appendChild(cone_dimensionsElement);
>> 187 }
>> 188
>> 189 void G4GDMLWriteParamvol::
>> 190 Sphere_dimensionsWrite(xercesc::DOMElement* parametersElement,
>> 191 const G4Sphere* const sphere)
>> 192 {
>> 193 xercesc::DOMElement* sphere_dimensionsElement =
>> 194 NewElement("sphere_dimensions");
>> 195 sphere_dimensionsElement->setAttributeNode(NewAttribute("rmin",
>> 196 sphere->GetInsideRadius()/mm));
>> 197 sphere_dimensionsElement->setAttributeNode(NewAttribute("rmax",
>> 198 sphere->GetOuterRadius()/mm));
>> 199 sphere_dimensionsElement->setAttributeNode(NewAttribute("startphi",
>> 200 sphere->GetStartPhiAngle()/degree));
>> 201 sphere_dimensionsElement->setAttributeNode(NewAttribute("deltaphi",
>> 202 sphere->GetDeltaPhiAngle()/degree));
>> 203 sphere_dimensionsElement->setAttributeNode(NewAttribute("starttheta",
>> 204 sphere->GetStartThetaAngle()/degree));
>> 205 sphere_dimensionsElement->setAttributeNode(NewAttribute("deltatheta",
>> 206 sphere->GetDeltaThetaAngle()/degree));
>> 207 sphere_dimensionsElement->setAttributeNode(NewAttribute("aunit","deg"));
>> 208 sphere_dimensionsElement->setAttributeNode(NewAttribute("lunit","mm"));
>> 209 parametersElement->appendChild(sphere_dimensionsElement);
>> 210 }
>> 211
>> 212 void G4GDMLWriteParamvol::
>> 213 Orb_dimensionsWrite(xercesc::DOMElement* parametersElement,
>> 214 const G4Orb* const orb)
>> 215 {
>> 216 xercesc::DOMElement* orb_dimensionsElement = NewElement("orb_dimensions");
>> 217 orb_dimensionsElement->setAttributeNode(NewAttribute("r",
>> 218 orb->GetRadius()/mm));
>> 219 orb_dimensionsElement->setAttributeNode(NewAttribute("lunit","mm"));
>> 220 parametersElement->appendChild(orb_dimensionsElement);
>> 221 }
>> 222
>> 223 void G4GDMLWriteParamvol::
>> 224 Torus_dimensionsWrite(xercesc::DOMElement* parametersElement,
>> 225 const G4Torus* const torus)
>> 226 {
>> 227 xercesc::DOMElement* torus_dimensionsElement =
>> 228 NewElement("torus_dimensions");
>> 229 torus_dimensionsElement->
>> 230 setAttributeNode(NewAttribute("rmin",torus->GetRmin()/mm));
>> 231 torus_dimensionsElement->
>> 232 setAttributeNode(NewAttribute("rmax",torus->GetRmax()/mm));
>> 233 torus_dimensionsElement->
>> 234 setAttributeNode(NewAttribute("rtor",torus->GetRtor()/mm));
>> 235 torus_dimensionsElement->
>> 236 setAttributeNode(NewAttribute("startphi",torus->GetSPhi()/degree));
>> 237 torus_dimensionsElement->
>> 238 setAttributeNode(NewAttribute("deltaphi",torus->GetDPhi()/degree));
>> 239 torus_dimensionsElement->
>> 240 setAttributeNode(NewAttribute("aunit","deg"));
>> 241 torus_dimensionsElement->
>> 242 setAttributeNode(NewAttribute("lunit","mm"));
>> 243 parametersElement->appendChild(torus_dimensionsElement);
>> 244 }
>> 245
>> 246 void G4GDMLWriteParamvol::
>> 247 Para_dimensionsWrite(xercesc::DOMElement* parametersElement,
>> 248 const G4Para* const para)
>> 249 {
>> 250 const G4ThreeVector simaxis = para->GetSymAxis();
>> 251 const G4double alpha = std::atan(para->GetTanAlpha());
>> 252 const G4double theta = std::acos(simaxis.z());
>> 253 const G4double phi = (simaxis.z() != 1.0)
>> 254 ? (std::atan(simaxis.y()/simaxis.x())) : (0.0);
>> 255
>> 256 xercesc::DOMElement* para_dimensionsElement = NewElement("para_dimensions");
>> 257 para_dimensionsElement->
>> 258 setAttributeNode(NewAttribute("x",2.0*para->GetXHalfLength()/mm));
>> 259 para_dimensionsElement->
>> 260 setAttributeNode(NewAttribute("y",2.0*para->GetYHalfLength()/mm));
>> 261 para_dimensionsElement->
>> 262 setAttributeNode(NewAttribute("z",2.0*para->GetZHalfLength()/mm));
>> 263 para_dimensionsElement->
>> 264 setAttributeNode(NewAttribute("alpha",alpha/degree));
>> 265 para_dimensionsElement->
>> 266 setAttributeNode(NewAttribute("theta",theta/degree));
>> 267 para_dimensionsElement->
>> 268 setAttributeNode(NewAttribute("phi",phi/degree));
>> 269 para_dimensionsElement->
>> 270 setAttributeNode(NewAttribute("aunit","deg"));
>> 271 para_dimensionsElement->
>> 272 setAttributeNode(NewAttribute("lunit","mm"));
>> 273 parametersElement->appendChild(para_dimensionsElement);
>> 274 }
>> 275
>> 276 void G4GDMLWriteParamvol::
>> 277 Hype_dimensionsWrite(xercesc::DOMElement* parametersElement,
>> 278 const G4Hype* const hype)
>> 279 {
>> 280 xercesc::DOMElement* hype_dimensionsElement = NewElement("hype_dimensions");
>> 281 hype_dimensionsElement->
>> 282 setAttributeNode(NewAttribute("rmin",hype->GetInnerRadius()/mm));
>> 283 hype_dimensionsElement->
>> 284 setAttributeNode(NewAttribute("rmax",hype->GetOuterRadius()/mm));
>> 285 hype_dimensionsElement->
>> 286 setAttributeNode(NewAttribute("inst",hype->GetInnerStereo()/degree));
>> 287 hype_dimensionsElement->
>> 288 setAttributeNode(NewAttribute("outst",hype->GetOuterStereo()/degree));
>> 289 hype_dimensionsElement->
>> 290 setAttributeNode(NewAttribute("z",2.0*hype->GetZHalfLength()/mm));
>> 291 hype_dimensionsElement->
>> 292 setAttributeNode(NewAttribute("aunit","deg"));
>> 293 hype_dimensionsElement->
>> 294 setAttributeNode(NewAttribute("lunit","mm"));
>> 295 parametersElement->appendChild(hype_dimensionsElement);
>> 296 }
>> 297
>> 298 void G4GDMLWriteParamvol::
>> 299 ParametersWrite(xercesc::DOMElement* paramvolElement,
>> 300 const G4VPhysicalVolume* const paramvol,const G4int& index)
>> 301 {
>> 302 paramvol->GetParameterisation()
>> 303 ->ComputeTransformation(index, const_cast<G4VPhysicalVolume*>(paramvol));
>> 304 G4ThreeVector Angles;
>> 305 G4String name = GenerateName(paramvol->GetName(),paramvol);
>> 306 std::stringstream os;
>> 307 os.precision(15);
>> 308 os << index;
>> 309 G4String sncopie = os.str();
>> 310
>> 311 xercesc::DOMElement* parametersElement = NewElement("parameters");
>> 312 parametersElement->setAttributeNode(NewAttribute("number",index+1));
>> 313
>> 314 PositionWrite(parametersElement, name+sncopie+"_pos",
>> 315 paramvol->GetObjectTranslation());
>> 316 Angles=GetAngles(paramvol->GetObjectRotationValue());
>> 317 if (Angles.mag2()>DBL_EPSILON)
>> 318 {
>> 319 RotationWrite(parametersElement, name+sncopie+"_rot",
>> 320 GetAngles(paramvol->GetObjectRotationValue()));
>> 321 }
>> 322 paramvolElement->appendChild(parametersElement);
>> 323
>> 324 G4VSolid* solid = paramvol->GetLogicalVolume()->GetSolid();
>> 325
>> 326 if (G4Box* box = dynamic_cast<G4Box*>(solid))
>> 327 {
>> 328 paramvol->GetParameterisation()->ComputeDimensions(*box,index,
>> 329 const_cast<G4VPhysicalVolume*>(paramvol));
>> 330 Box_dimensionsWrite(parametersElement,box);
>> 331 } else
>> 332 if (G4Trd* trd = dynamic_cast<G4Trd*>(solid))
>> 333 {
>> 334 paramvol->GetParameterisation()->ComputeDimensions(*trd,index,
>> 335 const_cast<G4VPhysicalVolume*>(paramvol));
>> 336 Trd_dimensionsWrite(parametersElement,trd);
>> 337 } else
>> 338 if (G4Trap* trap = dynamic_cast<G4Trap*>(solid))
>> 339 {
>> 340 paramvol->GetParameterisation()->ComputeDimensions(*trap,index,
>> 341 const_cast<G4VPhysicalVolume*>(paramvol));
>> 342 Trap_dimensionsWrite(parametersElement,trap);
>> 343 } else
>> 344 if (G4Tubs* tube = dynamic_cast<G4Tubs*>(solid))
>> 345 {
>> 346 paramvol->GetParameterisation()->ComputeDimensions(*tube,index,
>> 347 const_cast<G4VPhysicalVolume*>(paramvol));
>> 348 Tube_dimensionsWrite(parametersElement,tube);
>> 349 } else
>> 350 if (G4Cons* cone = dynamic_cast<G4Cons*>(solid))
>> 351 {
>> 352 paramvol->GetParameterisation()->ComputeDimensions(*cone,index,
>> 353 const_cast<G4VPhysicalVolume*>(paramvol));
>> 354 Cone_dimensionsWrite(parametersElement,cone);
>> 355 } else
>> 356 if (G4Sphere* sphere = dynamic_cast<G4Sphere*>(solid))
>> 357 {
>> 358 paramvol->GetParameterisation()->ComputeDimensions(*sphere,index,
>> 359 const_cast<G4VPhysicalVolume*>(paramvol));
>> 360 Sphere_dimensionsWrite(parametersElement,sphere);
>> 361 } else
>> 362 if (G4Orb* orb = dynamic_cast<G4Orb*>(solid))
>> 363 {
>> 364 paramvol->GetParameterisation()->ComputeDimensions(*orb,index,
>> 365 const_cast<G4VPhysicalVolume*>(paramvol));
>> 366 Orb_dimensionsWrite(parametersElement,orb);
>> 367 } else
>> 368 if (G4Torus* torus = dynamic_cast<G4Torus*>(solid))
>> 369 {
>> 370 paramvol->GetParameterisation()->ComputeDimensions(*torus,index,
>> 371 const_cast<G4VPhysicalVolume*>(paramvol));
>> 372 Torus_dimensionsWrite(parametersElement,torus);
>> 373 } else
>> 374 if (G4Para* para = dynamic_cast<G4Para*>(solid))
>> 375 {
>> 376 paramvol->GetParameterisation()->ComputeDimensions(*para,index,
>> 377 const_cast<G4VPhysicalVolume*>(paramvol));
>> 378 Para_dimensionsWrite(parametersElement,para);
>> 379 } else
>> 380 if (G4Hype* hype = dynamic_cast<G4Hype*>(solid))
>> 381 {
>> 382 paramvol->GetParameterisation()->ComputeDimensions(*hype,index,
>> 383 const_cast<G4VPhysicalVolume*>(paramvol));
>> 384 Hype_dimensionsWrite(parametersElement,hype);
>> 385 }
>> 386 else
>> 387 {
>> 388 G4String error_msg = "Solid '" + solid->GetName()
>> 389 + "' cannot be used in parameterised volume!";
>> 390 G4Exception("G4GDMLWriteParamvol::ParametersWrite()",
>> 391 "InvalidSetup", FatalException, error_msg);
>> 392 }
>> 393 }
>> 394
>> 395 void G4GDMLWriteParamvol::
>> 396 ParamvolWrite(xercesc::DOMElement* volumeElement,
>> 397 const G4VPhysicalVolume* const paramvol)
>> 398 {
>> 399 const G4String volumeref =
>> 400 GenerateName(paramvol->GetLogicalVolume()->GetName(),
>> 401 paramvol->GetLogicalVolume());
>> 402 xercesc::DOMElement* paramvolElement = NewElement("paramvol");
>> 403 paramvolElement->setAttributeNode(NewAttribute("ncopies",
>> 404 paramvol->GetMultiplicity()));
>> 405 xercesc::DOMElement* volumerefElement = NewElement("volumeref");
>> 406 volumerefElement->setAttributeNode(NewAttribute("ref",volumeref));
>> 407
>> 408 xercesc::DOMElement* algorithmElement =
>> 409 NewElement("parameterised_position_size");
>> 410 paramvolElement->appendChild(volumerefElement);
>> 411 paramvolElement->appendChild(algorithmElement);
>> 412 ParamvolAlgorithmWrite(algorithmElement,paramvol);
>> 413 volumeElement->appendChild(paramvolElement);
>> 414 }
>> 415
>> 416 void G4GDMLWriteParamvol::
>> 417 ParamvolAlgorithmWrite(xercesc::DOMElement* paramvolElement,
>> 418 const G4VPhysicalVolume* const paramvol)
>> 419 {
>> 420 const G4String volumeref =
>> 421 GenerateName(paramvol->GetLogicalVolume()->GetName(),
>> 422 paramvol->GetLogicalVolume());
>> 423
>> 424 const G4int parameterCount = paramvol->GetMultiplicity();
>> 425
>> 426 for (G4int i=0; i<parameterCount; i++)
>> 427 {
>> 428 ParametersWrite(paramvolElement,paramvol,i);
>> 429 }
510 } 430 }
511 431