source: trunk/source/persistency/gdml/src/G4GDMLStructure.cc@ 1287

Last change on this file since 1287 was 818, checked in by garnier, 17 years ago

import all except CVS
File size: 18.5 KB
RevLine 
[818]1//
2// ********************************************************************
3// * License and Disclaimer *
4// * *
5// * The Geant4 software is copyright of the Copyright Holders of *
6// * the Geant4 Collaboration. It is provided under the terms and *
7// * conditions of the Geant4 Software License, included in the file *
8// * LICENSE and available at http://cern.ch/geant4/license . These *
9// * include a list of copyright holders. *
10// * *
11// * Neither the authors of this software system, nor their employing *
12// * institutes,nor the agencies providing financial support for this *
13// * work make any representation or warranty, express or implied, *
14// * regarding this software system or assume any liability for its *
15// * use. Please see the license in the file LICENSE and URL above *
16// * for the full disclaimer and the limitation of liability. *
17// * *
18// * This code implementation is the result of the scientific and *
19// * technical work of the GEANT4 collaboration. *
20// * By using, copying, modifying or distributing the software (or *
21// * any work based on the software) you agree to acknowledge its *
22// * use in resulting scientific publications, and indicate your *
23// * acceptance of all terms of the Geant4 Software license. *
24// ********************************************************************
25//
26//
27// $Id: G4GDMLStructure.cc,v 1.25.2.1 2008/01/16 09:44:28 ztorzsok Exp $
28// GEANT4 tag $ Name:$
29//
30// class G4GDMLStructure Implementation
31//
32// Original author: Zoltan Torzsok, November 2007
33//
34// --------------------------------------------------------------------
35
36#include "G4GDMLStructure.hh"
37
38EAxis G4GDMLStructure::directionRead(const xercesc::DOMElement* const element) {
39
40 G4String x;
41 G4String y;
42 G4String z;
43
44 const xercesc::DOMNamedNodeMap* const attributes = element->getAttributes();
45 XMLSize_t attributeCount = attributes->getLength();
46
47 for (XMLSize_t attribute_index=0;attribute_index<attributeCount;attribute_index++) {
48
49 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
50
51 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE) continue;
52
53 const xercesc::DOMAttr* const attribute = dynamic_cast<xercesc::DOMAttr*>(attribute_node);
54
55 const G4String attribute_name = xercesc::XMLString::transcode(attribute->getName());
56 const G4String attribute_value = xercesc::XMLString::transcode(attribute->getValue());
57
58 if (attribute_name=="x") x = attribute_value; else
59 if (attribute_name=="y") y = attribute_value; else
60 if (attribute_name=="z") z = attribute_value;
61 }
62
63 G4double _x = eval.Evaluate(x);
64 G4double _y = eval.Evaluate(y);
65 G4double _z = eval.Evaluate(z);
66
67 if (_x == 1.0 && _y == 0.0 && _z == 0.0) return kXAxis; else
68 if (_x == 0.0 && _y == 1.0 && _z == 0.0) return kYAxis; else
69 if (_x == 0.0 && _y == 0.0 && _z == 1.0) return kZAxis;
70
71 G4Exception("GDML: Only directions along axes are supported!");
72
73 return kZAxis;
74}
75
76void G4GDMLStructure::divisionvolRead(const xercesc::DOMElement* const element,G4LogicalVolume* pMother) {
77
78 G4String unit("1");
79 G4String axis;
80 G4String width;
81 G4String offset;
82 G4String number;
83 G4String volumeref;
84
85 const xercesc::DOMNamedNodeMap* const attributes = element->getAttributes();
86 XMLSize_t attributeCount = attributes->getLength();
87
88 for (XMLSize_t attribute_index=0;attribute_index<attributeCount;attribute_index++) {
89
90 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
91
92 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE) continue;
93
94 const xercesc::DOMAttr* const attribute = dynamic_cast<xercesc::DOMAttr*>(attribute_node);
95
96 const G4String attribute_name = xercesc::XMLString::transcode(attribute->getName());
97 const G4String attribute_value = xercesc::XMLString::transcode(attribute->getValue());
98
99 if (attribute_name=="unit") unit = attribute_value; else
100 if (attribute_name=="axis") axis = attribute_value; else
101 if (attribute_name=="width") width = attribute_value; else
102 if (attribute_name=="offset") offset = attribute_value; else
103 if (attribute_name=="number") number = attribute_value;
104 }
105
106 for (xercesc::DOMNode* iter = element->getFirstChild();iter != 0;iter = iter->getNextSibling()) {
107
108 if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE) continue;
109
110 const xercesc::DOMElement* const child = dynamic_cast<xercesc::DOMElement*>(iter);
111
112 const G4String tag = xercesc::XMLString::transcode(child->getTagName());
113
114 if (tag=="volumeref") volumeref = refRead(child);
115 }
116
117 G4LogicalVolume* pLogical = getVolume(GenerateName(volumeref));
118
119 G4double _unit = eval.Evaluate(unit);
120
121 G4double _width = eval.Evaluate(width)*_unit;
122 G4double _offset = eval.Evaluate(offset)*_unit;
123 G4double _number = eval.Evaluate(number);
124
125 EAxis _axis = kZAxis;
126
127 if (axis=="kXAxis") _axis = kXAxis; else
128 if (axis=="kYAxis") _axis = kYAxis; else
129 if (axis=="kZAxis") _axis = kZAxis; else
130 if (axis=="kRho") _axis = kRho; else
131 if (axis=="kPhi") _axis = kPhi;
132
133 new G4PVDivision("",pLogical,pMother,_axis,(G4int)_number,_width,_offset);
134}
135
136G4LogicalVolume* G4GDMLStructure::fileRead(const xercesc::DOMElement* const element) {
137
138 G4String name;
139 G4String volname;
140
141 const xercesc::DOMNamedNodeMap* const attributes = element->getAttributes();
142 XMLSize_t attributeCount = attributes->getLength();
143
144 for (XMLSize_t attribute_index=0;attribute_index<attributeCount;attribute_index++) {
145
146 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
147
148 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE) continue;
149
150 const xercesc::DOMAttr* const attribute = dynamic_cast<xercesc::DOMAttr*>(attribute_node);
151
152 const G4String attribute_name = xercesc::XMLString::transcode(attribute->getName());
153 const G4String attribute_value = xercesc::XMLString::transcode(attribute->getValue());
154
155 if (attribute_name=="name") name = attribute_value; else
156 if (attribute_name=="volname") volname = attribute_value;
157 }
158
159 G4GDMLStructure structure; // We create a new structure with a new evaluator
160
161 structure.Parse(name);
162
163 if (volname.empty()) return structure.getVolume(structure.getSetup("Default"));
164
165 return structure.getVolume(structure.GenerateName(volname));
166}
167
168void G4GDMLStructure::loopRead(const xercesc::DOMElement* const element) {
169
170 G4String var;
171 G4String from;
172 G4String to;
173 G4String step;
174
175 const xercesc::DOMNamedNodeMap* const attributes = element->getAttributes();
176 XMLSize_t attributeCount = attributes->getLength();
177
178 for (XMLSize_t attribute_index=0;attribute_index<attributeCount;attribute_index++) {
179
180 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
181
182 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE) continue;
183
184 const xercesc::DOMAttr* const attribute = dynamic_cast<xercesc::DOMAttr*>(attribute_node);
185
186 const G4String attribute_name = xercesc::XMLString::transcode(attribute->getName());
187 const G4String attribute_value = xercesc::XMLString::transcode(attribute->getValue());
188
189 if (attribute_name=="var") var = attribute_value; else
190 if (attribute_name=="from") from = attribute_value; else
191 if (attribute_name=="to") to = attribute_value; else
192 if (attribute_name=="step") step = attribute_value;
193 }
194
195 eval.checkVariable(var);
196
197 G4int _var = eval.EvaluateInteger(var );
198 G4int _from = eval.EvaluateInteger(from);
199 G4int _to = eval.EvaluateInteger(to );
200 G4int _step = eval.EvaluateInteger(step);
201
202 if (!from.empty()) _var = _from;
203
204 while (_var <= _to) {
205
206 eval.setVariable(var,_var);
207 structureRead(element);
208
209 _var += _step;
210 }
211}
212
213void G4GDMLStructure::paramvolRead(const xercesc::DOMElement* const element,G4LogicalVolume *pMotherLogical) {
214
215 pMotherLogical = 0;
216
217 G4String volumeref;
218 G4String parameterised_position_size;
219
220 for (xercesc::DOMNode* iter = element->getFirstChild();iter != 0;iter = iter->getNextSibling()) {
221
222 if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE) continue;
223
224 const xercesc::DOMElement* const child = dynamic_cast<xercesc::DOMElement*>(iter);
225
226 const G4String tag = xercesc::XMLString::transcode(child->getTagName());
227
228 if (tag=="parameterised_position_size") { ; } else
229 if (tag=="volumeref") volumeref = refRead(child);
230 }
231}
232
233void G4GDMLStructure::physvolRead(const xercesc::DOMElement* const element,G4LogicalVolume *mother) {
234
235 G4String volumeref;
236 G4String positionref;
237 G4String rotationref;
238 G4String scaleref;
239
240 G4LogicalVolume* logvol = 0;
241
242 G4ThreeVector position;
243 G4ThreeVector rotation;
244 G4ThreeVector scale(1.0,1.0,1.0);
245
246 for (xercesc::DOMNode* iter = element->getFirstChild();iter != 0;iter = iter->getNextSibling()) {
247
248 if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE) continue;
249
250 const xercesc::DOMElement* const child = dynamic_cast<xercesc::DOMElement*>(iter);
251
252 const G4String tag = xercesc::XMLString::transcode(child->getTagName());
253
254 if (tag=="file") logvol = fileRead(child); else
255 if (tag=="volumeref") volumeref = refRead(child); else
256 if (tag=="position") position = positionRead(child); else
257 if (tag=="rotation") rotation = rotationRead(child); else
258 if (tag=="scale") scale = scaleRead(child); else
259 if (tag=="positionref") positionref = refRead(child); else
260 if (tag=="rotationref") rotationref = refRead(child); else
261 if (tag=="scaleref") scaleref = refRead(child);
262 }
263
264 if (!volumeref.empty()) logvol = getVolume(GenerateName(volumeref));
265
266 if (!positionref.empty()) position = *getPosition(GenerateName(positionref));
267 if (!rotationref.empty()) rotation = *getRotation(GenerateName(rotationref));
268 if (!scaleref.empty()) scale = *getScale(GenerateName(scaleref));
269
270 G4RotationMatrix Rot;
271
272 Rot.rotateX(rotation.x());
273 Rot.rotateY(rotation.y());
274 Rot.rotateZ(rotation.z());
275
276 G4Transform3D transform(Rot.inverse(),position);
277 transform = transform*G4Scale3D(scale.x(),scale.y(),scale.z());
278
279 G4ReflectionFactory::Instance()->Place(transform,"",logvol,mother,false,0);
280}
281
282G4double G4GDMLStructure::quantityRead(const xercesc::DOMElement* const element) {
283
284 G4String value;
285 G4String unit("1");
286
287 const xercesc::DOMNamedNodeMap* const attributes = element->getAttributes();
288 XMLSize_t attributeCount = attributes->getLength();
289
290 for (XMLSize_t attribute_index=0;attribute_index<attributeCount;attribute_index++) {
291
292 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
293
294 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE) continue;
295
296 const xercesc::DOMAttr* const attribute = dynamic_cast<xercesc::DOMAttr*>(attribute_node);
297
298 const G4String attribute_name = xercesc::XMLString::transcode(attribute->getName());
299 const G4String attribute_value = xercesc::XMLString::transcode(attribute->getValue());
300
301 if (attribute_name=="value") value = attribute_value;
302 if (attribute_name=="unit") unit = attribute_value;
303 }
304
305 return eval.Evaluate(value)*eval.Evaluate(unit);
306}
307
308G4String G4GDMLStructure::refRead(const xercesc::DOMElement* const element) {
309
310 G4String ref;
311
312 const xercesc::DOMNamedNodeMap* const attributes = element->getAttributes();
313 XMLSize_t attributeCount = attributes->getLength();
314
315 for (XMLSize_t attribute_index=0;attribute_index<attributeCount;attribute_index++) {
316
317 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
318
319 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE) continue;
320
321 const xercesc::DOMAttr* const attribute = dynamic_cast<xercesc::DOMAttr*>(attribute_node);
322
323 const G4String attribute_name = xercesc::XMLString::transcode(attribute->getName());
324 const G4String attribute_value = xercesc::XMLString::transcode(attribute->getValue());
325
326 if (attribute_name=="ref") ref = attribute_value;
327 }
328
329 return ref;
330}
331
332void G4GDMLStructure::replicate_along_axisRead(const xercesc::DOMElement* const element,G4double& _width,G4double& _offset,EAxis& _axis) {
333
334 for (xercesc::DOMNode* iter = element->getFirstChild();iter != 0;iter = iter->getNextSibling()) {
335
336 if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE) continue;
337
338 const xercesc::DOMElement* const child = dynamic_cast<xercesc::DOMElement*>(iter);
339
340 const G4String tag = xercesc::XMLString::transcode(child->getTagName());
341
342 if (tag=="width") _width = quantityRead(child); else
343 if (tag=="offset") _offset = quantityRead(child); else
344 if (tag=="direction") _axis = directionRead(child);
345 }
346}
347
348void G4GDMLStructure::replicavolRead(const xercesc::DOMElement* const element,G4LogicalVolume* pMother) {
349
350 G4String volumeref;
351 G4String numb;
352
353 const xercesc::DOMNamedNodeMap* const attributes = element->getAttributes();
354 XMLSize_t attributeCount = attributes->getLength();
355
356 for (XMLSize_t attribute_index=0;attribute_index<attributeCount;attribute_index++) {
357
358 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
359
360 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE) continue;
361
362 const xercesc::DOMAttr* const attribute = dynamic_cast<xercesc::DOMAttr*>(attribute_node);
363
364 const G4String attribute_name = xercesc::XMLString::transcode(attribute->getName());
365 const G4String attribute_value = xercesc::XMLString::transcode(attribute->getValue());
366
367 if (attribute_name=="numb") numb = attribute_value;
368 }
369
370 G4double _numb = eval.Evaluate(numb);
371 G4double _width = 0.0;
372 G4double _offset = 0.0;
373 EAxis _axis;
374
375 for (xercesc::DOMNode* iter = element->getFirstChild();iter != 0;iter = iter->getNextSibling()) {
376
377 if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE) continue;
378
379 const xercesc::DOMElement* const child = dynamic_cast<xercesc::DOMElement*>(iter);
380
381 const G4String tag = xercesc::XMLString::transcode(child->getTagName());
382
383 if (tag=="volumeref") volumeref = refRead(child); else
384 if (tag=="replicate_along_axis") replicate_along_axisRead(child,_width,_offset,_axis);
385 }
386
387 G4LogicalVolume* pLogical = getVolume(GenerateName(volumeref));
388
389 new G4PVReplica("",pLogical,pMother,_axis,(G4int)_numb,_width,_offset);
390}
391
392void G4GDMLStructure::volumeRead(const xercesc::DOMElement* const element) {
393
394 G4String name;
395 G4String solidref;
396 G4String materialref;
397
398 XMLCh *name_attr = xercesc::XMLString::transcode("name");
399 name = xercesc::XMLString::transcode(element->getAttribute(name_attr));
400 xercesc::XMLString::release(&name_attr);
401
402 for (xercesc::DOMNode* iter = element->getFirstChild();iter != 0;iter = iter->getNextSibling()) {
403
404 if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE) continue;
405
406 const xercesc::DOMElement* const child = dynamic_cast<xercesc::DOMElement*>(iter);
407
408 const G4String tag = xercesc::XMLString::transcode(child->getTagName());
409
410 if (tag=="materialref") materialref = refRead(child); else
411 if (tag=="solidref") solidref = refRead(child);
412 }
413
414 G4Material* materialPtr = getMaterial(GenerateName(materialref));
415 G4VSolid* solidPtr = getSolid(GenerateName(solidref));
416
417 volume_contentRead(element,new G4LogicalVolume(solidPtr,materialPtr,GenerateName(name),0,0,0));
418}
419
420void G4GDMLStructure::volume_contentRead(const xercesc::DOMElement* const element,G4LogicalVolume* volumePtr) {
421
422 for (xercesc::DOMNode* iter = element->getFirstChild();iter != 0;iter = iter->getNextSibling()) {
423
424 if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE) continue;
425
426 const xercesc::DOMElement* const child = dynamic_cast<xercesc::DOMElement*>(iter);
427
428 const G4String tag = xercesc::XMLString::transcode(child->getTagName());
429
430 if (tag=="loop") volume_loopRead(child,volumePtr); else
431 if (tag=="paramvol") paramvolRead(child,volumePtr); else
432 if (tag=="physvol") physvolRead(child,volumePtr); else
433 if (tag=="replicavol") replicavolRead(child,volumePtr); else
434 if (tag=="divisionvol") divisionvolRead(child,volumePtr);
435 }
436}
437
438void G4GDMLStructure::volume_loopRead(const xercesc::DOMElement* const element,G4LogicalVolume* volumePtr) {
439
440 G4String var;
441 G4String from;
442 G4String to;
443 G4String step;
444
445 const xercesc::DOMNamedNodeMap* const attributes = element->getAttributes();
446 XMLSize_t attributeCount = attributes->getLength();
447
448 for (XMLSize_t attribute_index=0;attribute_index<attributeCount;attribute_index++) {
449
450 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
451
452 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE) continue;
453
454 const xercesc::DOMAttr* const attribute = dynamic_cast<xercesc::DOMAttr*>(attribute_node);
455
456 const G4String attribute_name = xercesc::XMLString::transcode(attribute->getName());
457 const G4String attribute_value = xercesc::XMLString::transcode(attribute->getValue());
458
459 if (attribute_name=="var") var = attribute_value; else
460 if (attribute_name=="from") from = attribute_value; else
461 if (attribute_name=="to") to = attribute_value; else
462 if (attribute_name=="step") step = attribute_value;
463 }
464
465 eval.checkVariable(var);
466
467 G4int _var = eval.EvaluateInteger(var);
468 G4int _from = eval.EvaluateInteger(from);
469 G4int _to = eval.EvaluateInteger(to);
470 G4int _step = eval.EvaluateInteger(step);
471
472 if (!from.empty()) _var = _from;
473
474 while (_var <= _to) {
475
476 eval.setVariable(var,_var);
477 volume_contentRead(element,volumePtr);
478
479 _var += _step;
480 }
481}
482
483void G4GDMLStructure::structureRead(const xercesc::DOMElement* const element) {
484
485 for (xercesc::DOMNode* iter = element->getFirstChild();iter != 0;iter = iter->getNextSibling()) {
486
487 if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE) continue;
488
489 const xercesc::DOMElement* const child = dynamic_cast<xercesc::DOMElement*>(iter);
490
491 const G4String tag = xercesc::XMLString::transcode(child->getTagName());
492
493 if (tag=="loop") loopRead(child); else
494 if (tag=="volume") volumeRead(child); else
495 G4Exception("GDML: Unknown tag in structure: "+tag);
496 }
497}
498
499G4LogicalVolume* G4GDMLStructure::getVolume(const G4String& ref) const {
500
501 G4LogicalVolume *volumePtr = G4LogicalVolumeStore::GetInstance()->GetVolume(ref,false);
502
503 if (!volumePtr) G4Exception("GDML: Referenced volume '"+ref+"' was not found!");
504
505 return volumePtr;
506}
Note: See TracBrowser for help on using the repository browser.