source: trunk/source/persistency/gdml/src/G4GDMLWriteStructure.cc

Last change on this file was 1347, checked in by garnier, 14 years ago

geant4 tag 9.4
File size: 18.7 KB
Line 
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: G4GDMLWriteStructure.cc,v 1.83 2010/10/14 16:19:40 gcosmo Exp $
28// GEANT4 tag $Name: gdml-V09-03-09 $
29//
30// class G4GDMLWriteStructure Implementation
31//
32// Original author: Zoltan Torzsok, November 2007
33//
34// --------------------------------------------------------------------
35
36#include "G4GDMLWriteStructure.hh"
37
38#include "G4Material.hh"
39#include "G4ReflectedSolid.hh"
40#include "G4DisplacedSolid.hh"
41#include "G4LogicalVolumeStore.hh"
42#include "G4PhysicalVolumeStore.hh"
43#include "G4PVDivision.hh"
44#include "G4PVReplica.hh"
45#include "G4OpticalSurface.hh"
46#include "G4LogicalSkinSurface.hh"
47#include "G4LogicalBorderSurface.hh"
48
49G4GDMLWriteStructure::G4GDMLWriteStructure()
50  : G4GDMLWriteParamvol()
51{
52}
53
54G4GDMLWriteStructure::~G4GDMLWriteStructure()
55{
56}
57
58void
59G4GDMLWriteStructure::DivisionvolWrite(xercesc::DOMElement* volumeElement,
60                                       const G4PVDivision* const divisionvol)
61{
62   EAxis axis = kUndefined;
63   G4int number = 0;
64   G4double width = 0.0;
65   G4double offset = 0.0;
66   G4bool consuming = false;
67
68   divisionvol->GetReplicationData(axis,number,width,offset,consuming);
69   axis = divisionvol->GetDivisionAxis();
70
71   G4String unitString("mm");
72   G4String axisString("kUndefined");
73   if (axis==kXAxis) { axisString = "kXAxis"; }
74   else if (axis==kYAxis) { axisString = "kYAxis"; }
75   else if (axis==kZAxis) { axisString = "kZAxis"; }
76   else if (axis==kRho)   { axisString = "kRho";     }
77   else if (axis==kPhi)   { axisString = "kPhi"; unitString = "rad"; }
78
79   const G4String name
80         = GenerateName(divisionvol->GetName(),divisionvol);
81   const G4String volumeref
82         = GenerateName(divisionvol->GetLogicalVolume()->GetName(),
83                        divisionvol->GetLogicalVolume());
84
85   xercesc::DOMElement* divisionvolElement = NewElement("divisionvol");
86   divisionvolElement->setAttributeNode(NewAttribute("axis",axisString));
87   divisionvolElement->setAttributeNode(NewAttribute("number",number));
88   divisionvolElement->setAttributeNode(NewAttribute("width",width));
89   divisionvolElement->setAttributeNode(NewAttribute("offset",offset));
90   divisionvolElement->setAttributeNode(NewAttribute("unit",unitString));
91   xercesc::DOMElement* volumerefElement = NewElement("volumeref");
92   volumerefElement->setAttributeNode(NewAttribute("ref",volumeref));
93   divisionvolElement->appendChild(volumerefElement);
94   volumeElement->appendChild(divisionvolElement);
95}
96
97void G4GDMLWriteStructure::PhysvolWrite(xercesc::DOMElement* volumeElement,
98                                        const G4VPhysicalVolume* const physvol,
99                                        const G4Transform3D& T,
100                                        const G4String& ModuleName)
101{
102   HepGeom::Scale3D scale;
103   HepGeom::Rotate3D rotate;
104   HepGeom::Translate3D translate;
105
106   T.getDecomposition(scale,rotate,translate);
107
108   const G4ThreeVector scl(scale(0,0),scale(1,1),scale(2,2));
109   const G4ThreeVector rot = GetAngles(rotate.getRotation());
110   const G4ThreeVector pos = T.getTranslation();
111
112   const G4String name = GenerateName(physvol->GetName(),physvol);
113
114   xercesc::DOMElement* physvolElement = NewElement("physvol");
115   physvolElement->setAttributeNode(NewAttribute("name",name));
116   volumeElement->appendChild(physvolElement);
117
118   const G4String volumeref
119         = GenerateName(physvol->GetLogicalVolume()->GetName(),
120                        physvol->GetLogicalVolume());
121
122   if (ModuleName.empty())
123   {
124      xercesc::DOMElement* volumerefElement = NewElement("volumeref");
125      volumerefElement->setAttributeNode(NewAttribute("ref",volumeref));
126      physvolElement->appendChild(volumerefElement);
127   }
128   else
129   {
130      xercesc::DOMElement* fileElement = NewElement("file");
131      fileElement->setAttributeNode(NewAttribute("name",ModuleName));
132      fileElement->setAttributeNode(NewAttribute("volname",volumeref));
133      physvolElement->appendChild(fileElement);
134   }
135
136   if (std::fabs(pos.x()) > kLinearPrecision
137    || std::fabs(pos.y()) > kLinearPrecision
138    || std::fabs(pos.z()) > kLinearPrecision)
139   {
140     PositionWrite(physvolElement,name+"_pos",pos);
141   }
142   if (std::fabs(rot.x()) > kAngularPrecision
143    || std::fabs(rot.y()) > kAngularPrecision
144    || std::fabs(rot.z()) > kAngularPrecision)
145   {
146     RotationWrite(physvolElement,name+"_rot",rot);
147   }
148   if (std::fabs(scl.x()-1.0) > kRelativePrecision
149    || std::fabs(scl.y()-1.0) > kRelativePrecision
150    || std::fabs(scl.z()-1.0) > kRelativePrecision)
151   {
152     ScaleWrite(physvolElement,name+"_scl",scl);
153   }
154}
155
156void G4GDMLWriteStructure::ReplicavolWrite(xercesc::DOMElement* volumeElement,
157                                     const G4VPhysicalVolume* const replicavol)
158{
159   EAxis axis = kUndefined;
160   G4int number = 0;
161   G4double width = 0.0;
162   G4double offset = 0.0;
163   G4bool consuming = false;
164   G4String unitString("mm");
165
166   replicavol->GetReplicationData(axis,number,width,offset,consuming);
167
168   const G4String volumeref
169         = GenerateName(replicavol->GetLogicalVolume()->GetName(),
170                        replicavol->GetLogicalVolume());
171
172   xercesc::DOMElement* replicavolElement = NewElement("replicavol");
173   replicavolElement->setAttributeNode(NewAttribute("number",number));
174   xercesc::DOMElement* volumerefElement = NewElement("volumeref");
175   volumerefElement->setAttributeNode(NewAttribute("ref",volumeref));
176   replicavolElement->appendChild(volumerefElement);
177   xercesc::DOMElement* replicateElement = NewElement("replicate_along_axis");
178   replicavolElement->appendChild(replicateElement);
179
180   xercesc::DOMElement* dirElement = NewElement("direction");
181   if(axis==kXAxis)
182     { dirElement->setAttributeNode(NewAttribute("x","1")); }
183   else if(axis==kYAxis)
184     { dirElement->setAttributeNode(NewAttribute("y","1")); }
185   else if(axis==kZAxis)
186     { dirElement->setAttributeNode(NewAttribute("z","1")); }
187   else if(axis==kRho)
188     { dirElement->setAttributeNode(NewAttribute("rho","1")); }
189   else if(axis==kPhi)
190     { dirElement->setAttributeNode(NewAttribute("phi","1"));
191       unitString="rad"; }
192   replicateElement->appendChild(dirElement);
193
194   xercesc::DOMElement* widthElement = NewElement("width");
195   widthElement->setAttributeNode(NewAttribute("value",width));
196   widthElement->setAttributeNode(NewAttribute("unit",unitString));
197   replicateElement->appendChild(widthElement);
198
199   xercesc::DOMElement* offsetElement = NewElement("offset");
200   offsetElement->setAttributeNode(NewAttribute("value",offset));
201   offsetElement->setAttributeNode(NewAttribute("unit",unitString));
202   replicateElement->appendChild(offsetElement);
203
204   volumeElement->appendChild(replicavolElement);
205}
206
207void G4GDMLWriteStructure::
208BorderSurfaceCache(const G4LogicalBorderSurface* const bsurf)
209{
210   if (!bsurf)  { return; }
211
212   const G4SurfaceProperty* psurf = bsurf->GetSurfaceProperty();
213
214   // Generate the new element for border-surface
215   //
216   xercesc::DOMElement* borderElement = NewElement("bordersurface");
217   borderElement->setAttributeNode(NewAttribute("name", bsurf->GetName()));
218   borderElement->setAttributeNode(NewAttribute("surfaceproperty",
219                                                psurf->GetName()));
220
221   const G4String volumeref1 = GenerateName(bsurf->GetVolume1()->GetName(),
222                                            bsurf->GetVolume1());
223   const G4String volumeref2 = GenerateName(bsurf->GetVolume2()->GetName(),
224                                            bsurf->GetVolume2());
225   xercesc::DOMElement* volumerefElement1 = NewElement("physvolref");
226   xercesc::DOMElement* volumerefElement2 = NewElement("physvolref");
227   volumerefElement1->setAttributeNode(NewAttribute("ref",volumeref1));
228   volumerefElement2->setAttributeNode(NewAttribute("ref",volumeref2));
229   borderElement->appendChild(volumerefElement1);
230   borderElement->appendChild(volumerefElement2);
231
232   if (FindOpticalSurface(psurf))
233   {
234     const G4OpticalSurface* opsurf =
235       dynamic_cast<const G4OpticalSurface*>(psurf);
236     if (!opsurf)
237     {
238       G4Exception("G4GDMLWriteStructure::BorderSurfaceCache()",
239                   "InvalidSetup", FatalException, "No optical surface found!");
240       return;
241     }
242     OpticalSurfaceWrite(solidsElement, opsurf);
243   }
244
245   borderElementVec.push_back(borderElement);
246}
247
248void G4GDMLWriteStructure::
249SkinSurfaceCache(const G4LogicalSkinSurface* const ssurf)
250{
251   if (!ssurf)  { return; }
252
253   const G4SurfaceProperty* psurf = ssurf->GetSurfaceProperty();
254
255   // Generate the new element for border-surface
256   //
257   xercesc::DOMElement* skinElement = NewElement("skinsurface");
258   skinElement->setAttributeNode(NewAttribute("name", ssurf->GetName()));
259   skinElement->setAttributeNode(NewAttribute("surfaceproperty",
260                                              psurf->GetName()));
261
262   const G4String volumeref = GenerateName(ssurf->GetLogicalVolume()->GetName(),
263                                           ssurf->GetLogicalVolume());
264   xercesc::DOMElement* volumerefElement = NewElement("volumeref");
265   volumerefElement->setAttributeNode(NewAttribute("ref",volumeref));
266   skinElement->appendChild(volumerefElement);
267
268   if (FindOpticalSurface(psurf))
269   {
270     const G4OpticalSurface* opsurf =
271       dynamic_cast<const G4OpticalSurface*>(psurf);
272     if (!opsurf)
273     {
274       G4Exception("G4GDMLWriteStructure::SkinSurfaceCache()",
275                   "InvalidSetup", FatalException, "No optical surface found!");
276       return;
277     }
278     OpticalSurfaceWrite(solidsElement, opsurf);
279   }
280
281   skinElementVec.push_back(skinElement);
282}
283
284G4bool G4GDMLWriteStructure::FindOpticalSurface(const G4SurfaceProperty* psurf)
285{
286   const G4OpticalSurface* osurf = dynamic_cast<const G4OpticalSurface*>(psurf);
287   std::vector<const G4OpticalSurface*>::const_iterator pos;
288   pos = std::find(opt_vec.begin(), opt_vec.end(), osurf);
289   if (pos != opt_vec.end()) { return false; }  // item already created!
290
291   opt_vec.push_back(osurf);              // cache it for future reference
292   return true;
293}
294
295const G4LogicalSkinSurface*
296G4GDMLWriteStructure::GetSkinSurface(const G4LogicalVolume* const lvol)
297{
298  G4LogicalSkinSurface* surf = 0;
299  G4int nsurf = G4LogicalSkinSurface::GetNumberOfSkinSurfaces();
300  if (nsurf)
301  {
302    const G4LogicalSkinSurfaceTable* stable =
303          G4LogicalSkinSurface::GetSurfaceTable();
304    std::vector<G4LogicalSkinSurface*>::const_iterator pos;
305    for (pos = stable->begin(); pos != stable->end(); pos++)
306    {
307      if (lvol == (*pos)->GetLogicalVolume())
308      {
309        surf = *pos; break;
310      }
311    }
312  }
313  return surf;
314}
315
316const G4LogicalBorderSurface*
317G4GDMLWriteStructure::GetBorderSurface(const G4VPhysicalVolume* const pvol)
318{
319  G4LogicalBorderSurface* surf = 0;
320  G4int nsurf = G4LogicalBorderSurface::GetNumberOfBorderSurfaces();
321  if (nsurf)
322  {
323    const G4LogicalBorderSurfaceTable* btable =
324          G4LogicalBorderSurface::GetSurfaceTable();
325    std::vector<G4LogicalBorderSurface*>::const_iterator pos;
326    for (pos = btable->begin(); pos != btable->end(); pos++)
327    {
328      if (pvol == (*pos)->GetVolume1())  // just the first in the couple
329      {                                  // is enough
330        surf = *pos; break;
331      }
332    }
333  }
334  return surf;
335}
336
337void G4GDMLWriteStructure::SurfacesWrite()
338{
339   G4cout << "G4GDML: Writing surfaces..." << G4endl;
340
341   std::vector<xercesc::DOMElement*>::const_iterator pos;
342   for (pos = skinElementVec.begin(); pos != skinElementVec.end(); pos++)
343   {
344     structureElement->appendChild(*pos);
345   }
346   for (pos = borderElementVec.begin(); pos != borderElementVec.end(); pos++)
347   {
348     structureElement->appendChild(*pos);
349   }
350}
351
352void G4GDMLWriteStructure::StructureWrite(xercesc::DOMElement* gdmlElement)
353{
354   G4cout << "G4GDML: Writing structure..." << G4endl;
355
356   structureElement = NewElement("structure");
357   gdmlElement->appendChild(structureElement);
358}
359
360G4Transform3D G4GDMLWriteStructure::
361TraverseVolumeTree(const G4LogicalVolume* const volumePtr, const G4int depth)
362{
363   if (VolumeMap().find(volumePtr) != VolumeMap().end())
364   {
365     return VolumeMap()[volumePtr]; // Volume is already processed
366   }
367
368   G4VSolid* solidPtr = volumePtr->GetSolid();
369   G4Transform3D R,invR;
370   G4int trans=0;
371
372   while (true) // Solve possible displacement/reflection
373   {            // of the referenced solid!
374      if (trans>maxTransforms)
375      {
376        G4String ErrorMessage = "Referenced solid in volume '"
377                              + volumePtr->GetName()
378                              + "' was displaced/reflected too many times!";
379        G4Exception("G4GDMLWriteStructure::TraverseVolumeTree()",
380                    "InvalidSetup", FatalException, ErrorMessage);
381      }
382
383      if (G4ReflectedSolid* refl = dynamic_cast<G4ReflectedSolid*>(solidPtr))
384      {
385         R = R*refl->GetTransform3D();
386         solidPtr = refl->GetConstituentMovedSolid();
387         trans++;
388         continue;
389      }
390
391      if (G4DisplacedSolid* disp = dynamic_cast<G4DisplacedSolid*>(solidPtr))
392      {
393         R = R*G4Transform3D(disp->GetObjectRotation(),
394                             disp->GetObjectTranslation());
395         solidPtr = disp->GetConstituentMovedSolid();
396         trans++;
397         continue;
398      }
399
400      break;
401   }
402
403   // Only compute the inverse when necessary!
404   //
405   if (trans>0) { invR = R.inverse(); }
406
407   const G4String name
408         = GenerateName(volumePtr->GetName(),volumePtr);
409   const G4String materialref
410         = GenerateName(volumePtr->GetMaterial()->GetName(),
411                        volumePtr->GetMaterial());
412   const G4String solidref
413         = GenerateName(solidPtr->GetName(),solidPtr);
414
415   xercesc::DOMElement* volumeElement = NewElement("volume");
416   volumeElement->setAttributeNode(NewAttribute("name",name));
417   xercesc::DOMElement* materialrefElement = NewElement("materialref");
418   materialrefElement->setAttributeNode(NewAttribute("ref",materialref));
419   volumeElement->appendChild(materialrefElement);
420   xercesc::DOMElement* solidrefElement = NewElement("solidref");
421   solidrefElement->setAttributeNode(NewAttribute("ref",solidref));
422   volumeElement->appendChild(solidrefElement);
423
424   const G4int daughterCount = volumePtr->GetNoDaughters();
425
426   for (G4int i=0;i<daughterCount;i++)   // Traverse all the children!
427   {
428      const G4VPhysicalVolume* const physvol = volumePtr->GetDaughter(i);
429      const G4String ModuleName = Modularize(physvol,depth);
430
431      G4Transform3D daughterR;
432
433      if (ModuleName.empty())   // Check if subtree requested to be
434      {                         // a separate module!
435         daughterR = TraverseVolumeTree(physvol->GetLogicalVolume(),depth+1);
436      }
437      else
438      {   
439         G4GDMLWriteStructure writer;
440         daughterR = writer.Write(ModuleName,physvol->GetLogicalVolume(),
441                                  SchemaLocation,depth+1);
442      }
443
444      if (const G4PVDivision* const divisionvol
445         = dynamic_cast<const G4PVDivision*>(physvol)) // Is it division?
446      {
447         if (!G4Transform3D::Identity.isNear(invR*daughterR,kRelativePrecision))
448         {
449            G4String ErrorMessage = "Division volume in '"
450                                  + name
451                                  + "' can not be related to reflected solid!";
452            G4Exception("G4GDMLWriteStructure::TraverseVolumeTree()",
453                        "InvalidSetup", FatalException, ErrorMessage);
454         }
455         DivisionvolWrite(volumeElement,divisionvol); 
456      } else 
457      if (physvol->IsParameterised())   // Is it a paramvol?
458      {
459         if (!G4Transform3D::Identity.isNear(invR*daughterR,kRelativePrecision))
460         {
461            G4String ErrorMessage = "Parameterised volume in '"
462                                  + name
463                                  + "' can not be related to reflected solid!";
464            G4Exception("G4GDMLWriteStructure::TraverseVolumeTree()",
465                        "InvalidSetup", FatalException, ErrorMessage);
466         }
467         ParamvolWrite(volumeElement,physvol);
468      } else
469      if (physvol->IsReplicated())   // Is it a replicavol?
470      {
471         if (!G4Transform3D::Identity.isNear(invR*daughterR,kRelativePrecision))
472         {
473            G4String ErrorMessage = "Replica volume in '"
474                                  + name
475                                  + "' can not be related to reflected solid!";
476            G4Exception("G4GDMLWriteStructure::TraverseVolumeTree()",
477                        "InvalidSetup", FatalException, ErrorMessage);
478         }
479         ReplicavolWrite(volumeElement,physvol); 
480      }
481      else   // Is it a physvol?
482      {
483         G4RotationMatrix rot;
484
485         if (physvol->GetFrameRotation() != 0)
486         {
487           rot = *(physvol->GetFrameRotation());
488         }
489         G4Transform3D P(rot,physvol->GetObjectTranslation());
490         PhysvolWrite(volumeElement,physvol,invR*P*daughterR,ModuleName);
491      }
492      BorderSurfaceCache(GetBorderSurface(physvol));
493   }
494
495   structureElement->appendChild(volumeElement);
496     // Append the volume AFTER traversing the children so that
497     // the order of volumes will be correct!
498
499   VolumeMap()[volumePtr] = R;
500
501   AddExtension(volumeElement, volumePtr);
502     // Add any possible user defined extension attached to a volume
503
504   AddMaterial(volumePtr->GetMaterial());
505     // Add the involved materials and solids!
506
507   AddSolid(solidPtr);
508
509   SkinSurfaceCache(GetSkinSurface(volumePtr));
510
511   return R;
512}
Note: See TracBrowser for help on using the repository browser.