Ignore:
Timestamp:
Jan 8, 2010, 11:56:51 AM (15 years ago)
Author:
garnier
Message:

update geant4.9.3 tag

Location:
trunk/source/persistency/gdml/include
Files:
19 edited

Legend:

Unmodified
Added
Removed

  • trunk/source/persistency/gdml/include/G4GDMLEvaluator.hh

    r987 r1228  
    2525//
    2626//
    27 // $Id: G4GDMLEvaluator.hh,v 1.16 2008/07/16 15:46:33 gcosmo Exp $
    28 // GEANT4 tag $Name: geant4-09-02-ref-02 $
     27// $Id: G4GDMLEvaluator.hh,v 1.17 2009/04/24 15:34:20 gcosmo Exp $
     28// GEANT4 tag $Name: geant4-09-03 $
    2929//
    3030//
    … …  
    4545#include <vector>
    4646
    47 #include "globals.hh"
     47#include "G4Types.hh"
    4848
    4949class G4GDMLEvaluator

  • trunk/source/persistency/gdml/include/G4GDMLParameterisation.hh

    r987 r1228  
    2626//
    2727// $Id: G4GDMLParameterisation.hh,v 1.10 2008/07/16 15:46:33 gcosmo Exp $
    28 // GEANT4 tag $Name: geant4-09-02-ref-02 $
     28// GEANT4 tag $Name: geant4-09-03 $
    2929//
    3030//

  • trunk/source/persistency/gdml/include/G4GDMLParser.hh

    r987 r1228  
    2525//
    2626//
    27 // $Id: G4GDMLParser.hh,v 1.57 2009/01/22 11:02:07 gcosmo Exp $
    28 // GEANT4 tag $Name: geant4-09-02-ref-02 $
     27// $Id: G4GDMLParser.hh,v 1.58 2009/04/15 13:29:30 gcosmo Exp $
     28// GEANT4 tag $Name: geant4-09-03 $
    2929//
    3030//
    … …  
    5454   G4GDMLParser();
    5555   G4GDMLParser(G4GDMLReadStructure*);
     56   G4GDMLParser(G4GDMLReadStructure*, G4GDMLWriteStructure*);
    5657  ~G4GDMLParser();
    5758     //
    … …  
    113114   G4GDMLReadStructure* reader;
    114115   G4GDMLWriteStructure* writer;
    115    G4bool ucode;
     116   G4bool urcode, uwcode;
    116117
    117118};

  • trunk/source/persistency/gdml/include/G4GDMLParser.icc

    r987 r1228  
    2626//
    2727// $Id: G4GDMLParser.icc,v 1.8 2009/01/22 11:02:07 gcosmo Exp $
    28 // GEANT4 tag $Name: geant4-09-02-ref-02 $
     28// GEANT4 tag $Name: geant4-09-03 $
    2929//
    3030//

  • trunk/source/persistency/gdml/include/G4GDMLRead.hh

    r987 r1228  
    2525//
    2626//
    27 // $Id: G4GDMLRead.hh,v 1.27 2009/01/22 11:02:07 gcosmo Exp $
    28 // GEANT4 tag $Name: geant4-09-02-ref-02 $
     27// $Id: G4GDMLRead.hh,v 1.31 2009/05/12 15:46:43 gcosmo Exp $
     28// GEANT4 tag $Name: geant4-09-03 $
    2929//
    3030// class G4GDMLRead
    … …  
    4747#include <xercesc/dom/DOM.hpp>
    4848
     49#include "G4Types.hh"
     50
    4951#include "G4GDMLEvaluator.hh"
    5052
    51 #include "G4LogicalVolume.hh"
    52 #include "G4VisAttributes.hh"
    53 #include "G4PVPlacement.hh"
    54 
    55 #include <sstream>
     53class G4LogicalVolume;
     54class G4VPhysicalVolume;
    5655
    5756class G4GDMLErrorHandler : public xercesc::ErrorHandler
    … …  
    149148 private:
    150149
    151    G4int inLoop;
     150   G4int inLoop, loopCount;
    152151
    153152};

  • trunk/source/persistency/gdml/include/G4GDMLReadDefine.hh

    r987 r1228  
    4141
    4242#include "G4ThreeVector.hh"
     43#include "G4RotationMatrix.hh"
     44
    4345#include "G4GDMLRead.hh"
    4446
    … …  
    5052   G4GDMLMatrix();
    5153   G4GDMLMatrix(size_t rows0,size_t cols0);
    52    ~G4GDMLMatrix();
     54   G4GDMLMatrix(const G4GDMLMatrix& rhs);
     55   G4GDMLMatrix& operator=(const G4GDMLMatrix& rhs);
     56  ~G4GDMLMatrix();
    5357
    5458   void Set(size_t r,size_t c,G4double a);
    … …  
    8084 protected:
    8185
     86   G4GDMLReadDefine();
     87   virtual ~G4GDMLReadDefine();
     88
    8289   G4RotationMatrix GetRotationMatrix(const G4ThreeVector&);
    8390   void VectorRead(const xercesc::DOMElement* const,G4ThreeVector&);
    … …  
    9097   void ScaleRead(const xercesc::DOMElement* const);
    9198   void VariableRead(const xercesc::DOMElement* const);
    92    void QuantityRead(const xercesc::DOMElement* const);
     99   void QuantityRead(const xercesc::DOMElement* const);
     100   void ExpressionRead(const xercesc::DOMElement* const);
    93101
    94102 protected:

  • trunk/source/persistency/gdml/include/G4GDMLReadMaterials.hh

    r987 r1228  
    2525//
    2626//
    27 // $Id: G4GDMLReadMaterials.hh,v 1.9 2008/11/20 15:33:52 gcosmo Exp $
    28 // GEANT4 tag $Name: geant4-09-02-ref-02 $
     27// $Id: G4GDMLReadMaterials.hh,v 1.11 2009/04/24 15:34:20 gcosmo Exp $
     28// GEANT4 tag $Name: geant4-09-03 $
    2929//
    3030//
    … …  
    4343#define _G4GDMLREADMATERIALS_INCLUDED_
    4444
    45 #include "G4Element.hh"
    46 #include "G4Isotope.hh"
    47 #include "G4Material.hh"
    48 #include "G4NistManager.hh"
     45#include "G4Types.hh"
     46#include "G4GDMLReadDefine.hh"
    4947
    50 #include "G4GDMLReadDefine.hh"
     48class G4Element;
     49class G4Isotope;
     50class G4Material;
    5151
    5252class G4GDMLReadMaterials : public G4GDMLReadDefine
    … …  
    6262
    6363 protected:
     64
     65   G4GDMLReadMaterials();
     66   virtual ~G4GDMLReadMaterials();
    6467
    6568   G4double AtomRead(const xercesc::DOMElement* const);

  • trunk/source/persistency/gdml/include/G4GDMLReadParamvol.hh

    r987 r1228  
    2525//
    2626//
    27 // $Id: G4GDMLReadParamvol.hh,v 1.6 2008/11/20 15:33:52 gcosmo Exp $
    28 // GEANT4 tag $Name: geant4-09-02-ref-02 $
     27// $Id: G4GDMLReadParamvol.hh,v 1.8 2009/04/24 15:34:20 gcosmo Exp $
     28// GEANT4 tag $Name: geant4-09-03 $
    2929//
    3030//
    … …  
    4242#define _G4GDMLREADPARAMVOL_INCLUDED_
    4343
    44 #include "G4LogicalVolume.hh"
    45 #include "G4PVParameterised.hh"
    46 #include "G4PVPlacement.hh"
    47 #include "G4VPhysicalVolume.hh"
     44#include "G4GDMLReadSetup.hh"
     45#include "G4GDMLParameterisation.hh"
    4846
    49 #include "G4GDMLParameterisation.hh"
    50 #include "G4GDMLReadSetup.hh"
     47class G4LogicalVolume;
    5148
    5249class G4GDMLReadParamvol : public G4GDMLReadSetup
    … …  
    6057
    6158 protected:
     59
     60   G4GDMLReadParamvol();
     61   virtual ~G4GDMLReadParamvol();
    6262
    6363   void Box_dimensionsRead(const xercesc::DOMElement* const,

  • trunk/source/persistency/gdml/include/G4GDMLReadSetup.hh

    r987 r1228  
    2525//
    2626//
    27 // $Id: G4GDMLReadSetup.hh,v 1.5 2008/11/20 15:33:52 gcosmo Exp $
    28 // GEANT4 tag $Name: geant4-09-02-ref-02 $
     27// $Id: G4GDMLReadSetup.hh,v 1.6 2009/03/24 15:47:33 gcosmo Exp $
     28// GEANT4 tag $Name: geant4-09-03 $
    2929//
    3030//
    … …  
    5858 protected:
    5959
     60   G4GDMLReadSetup();
     61   virtual ~G4GDMLReadSetup();
     62
     63 protected:
     64
    6065   std::map<G4String,G4String> setupMap;
    6166};

  • trunk/source/persistency/gdml/include/G4GDMLReadSolids.hh

    r987 r1228  
    2525//
    2626//
    27 // $Id: G4GDMLReadSolids.hh,v 1.12 2008/11/21 09:32:46 gcosmo Exp $
    28 // GEANT4 tag $Name: geant4-09-02-ref-02 $
     27// $Id: G4GDMLReadSolids.hh,v 1.15 2009/04/24 15:34:20 gcosmo Exp $
     28// GEANT4 tag $Name: geant4-09-03 $
    2929//
    3030//
    … …  
    4242#define _G4GDMLREADSOLIDS_INCLUDED_
    4343
    44 #include "G4Box.hh"
    45 #include "G4Cons.hh"
    46 #include "G4Ellipsoid.hh"
    47 #include "G4EllipticalCone.hh"
    48 #include "G4EllipticalTube.hh"
     44#include "G4Types.hh"
     45#include "G4GDMLReadMaterials.hh"
    4946#include "G4ExtrudedSolid.hh"
    50 #include "G4Hype.hh"
    51 #include "G4IntersectionSolid.hh"
    52 #include "G4Orb.hh"
    53 #include "G4Para.hh"
    54 #include "G4Paraboloid.hh"
    55 #include "G4Polycone.hh"
    56 #include "G4Polyhedra.hh"
    57 #include "G4QuadrangularFacet.hh"
    58 #include "G4ReflectedSolid.hh"
    59 #include "G4Sphere.hh"
    60 #include "G4SolidStore.hh"
    61 #include "G4SubtractionSolid.hh"
    62 #include "G4TessellatedSolid.hh"
    63 #include "G4Tet.hh"
    64 #include "G4Torus.hh"
    65 #include "G4Transform3D.hh"
    66 #include "G4Trap.hh"
    67 #include "G4Trd.hh"
    68 #include "G4TriangularFacet.hh"
    69 #include "G4Tubs.hh"
    70 #include "G4TwistedBox.hh"
    71 #include "G4TwistedTrap.hh"
    72 #include "G4TwistedTrd.hh"
    73 #include "G4TwistedTubs.hh"
    74 #include "G4UnionSolid.hh"
    75 #include "G4OpticalSurface.hh"
    76 #include "G4SurfaceProperty.hh"
    7747
    78 #include "G4GDMLReadMaterials.hh"
     48class G4VSolid;
     49class G4QuadrangularFacet;
     50class G4TriangularFacet;
     51class G4SurfaceProperty;
    7952
    8053class G4GDMLReadSolids : public G4GDMLReadMaterials
    … …  
    9164
    9265 protected:
     66
     67   G4GDMLReadSolids();
     68   virtual ~G4GDMLReadSolids();
    9369
    9470   void BooleanRead(const xercesc::DOMElement* const,const BooleanOp);
    … …  
    12298   G4TwoVector TwoDimVertexRead(const xercesc::DOMElement* const,G4double);
    12399   zplaneType ZplaneRead(const xercesc::DOMElement* const);
    124    void OpticalsurfaceRead(const xercesc::DOMElement* const);
     100   void OpticalSurfaceRead(const xercesc::DOMElement* const);
    125101};
    126102

  • trunk/source/persistency/gdml/include/G4GDMLReadStructure.hh

    r987 r1228  
    2525//
    2626//
    27 // $Id: G4GDMLReadStructure.hh,v 1.24 2009/02/24 17:41:44 gcosmo Exp $
    28 // GEANT4 tag $Name: geant4-09-02-ref-02 $
     27// $Id: G4GDMLReadStructure.hh,v 1.28 2009/09/24 15:04:34 gcosmo Exp $
     28// GEANT4 tag $Name: geant4-09-03 $
    2929//
    3030//
    … …  
    4242#define _G4GDMLREADSTRUCTURE_INCLUDED_
    4343
    44 #include "G4AssemblyVolume.hh"
    45 #include "G4LogicalVolume.hh"
    46 #include "G4LogicalVolumeStore.hh"
    47 #include "G4PhysicalVolumeStore.hh"
    48 #include "G4PVDivision.hh"
    49 #include "G4PVPlacement.hh"
    50 #include "G4PVReplica.hh"
    51 #include "G4SolidStore.hh"
    52 #include "G4VPhysicalVolume.hh"
    53 #include "G4ReflectionFactory.hh"
    54 #include "G4PhysicalVolumeStore.hh"
    55 #include "G4LogicalSkinSurface.hh"
    56 #include "G4LogicalBorderSurface.hh"
    57 #include "G4PVDivisionFactory.hh"
     44#include "G4Types.hh"
     45#include "geomdefs.hh"
    5846
    5947#include "G4GDMLReadParamvol.hh"
     48
     49class G4AssemblyVolume;
     50class G4LogicalVolume;
     51class G4VPhysicalVolume;
    6052
    6153struct G4GDMLAuxPairType
    … …  
    6759typedef std::vector<G4GDMLAuxPairType> G4GDMLAuxListType;
    6860typedef std::map<const G4LogicalVolume*,G4GDMLAuxListType> G4GDMLAuxMapType;
     61typedef std::map<G4String, G4AssemblyVolume*> G4GDMLAssemblyMapType;
    6962
    7063class G4GDMLReadStructure : public G4GDMLReadParamvol
    … …  
    7366 public:
    7467
     68   G4GDMLReadStructure();
     69   virtual ~G4GDMLReadStructure();
     70
    7571   G4VPhysicalVolume* GetPhysvol(const G4String&) const;
    7672   G4LogicalVolume* GetVolume(const G4String&) const;
     73   G4AssemblyVolume* GetAssembly(const G4String&) const;
    7774   G4GDMLAuxListType GetVolumeAuxiliaryInformation(const G4LogicalVolume* const);
    7875   G4VPhysicalVolume* GetWorldVolume(const G4String&);
    … …  
    8683
    8784   G4GDMLAuxPairType AuxiliaryRead(const xercesc::DOMElement* const);
    88    void BordersurfaceRead(const xercesc::DOMElement* const);
     85   void AssemblyRead(const xercesc::DOMElement* const);
    8986   void DivisionvolRead(const xercesc::DOMElement* const);
    9087   G4LogicalVolume* FileRead(const xercesc::DOMElement* const);
    91    void PhysvolRead(const xercesc::DOMElement* const);
     88   void PhysvolRead(const xercesc::DOMElement* const,
     89                    G4AssemblyVolume* assembly=0);
    9290   void ReplicavolRead(const xercesc::DOMElement* const, G4int number);
    9391   void ReplicaRead(const xercesc::DOMElement* const replicaElement,
    … …  
    9593   EAxis AxisRead(const xercesc::DOMElement* const axisElement);
    9694   G4double QuantityRead(const xercesc::DOMElement* const readElement);
    97    void SkinsurfaceRead(const xercesc::DOMElement* const);
     95   void BorderSurfaceRead(const xercesc::DOMElement* const);
     96   void SkinSurfaceRead(const xercesc::DOMElement* const);
    9897
    9998 protected:
    10099
    101100   G4GDMLAuxMapType auxMap;
     101   G4GDMLAssemblyMapType assemblyMap;
    102102   G4LogicalVolume *pMotherLogical;
    103103

  • trunk/source/persistency/gdml/include/G4GDMLWrite.hh

    r987 r1228  
    2525//
    2626//
    27 // $Id: G4GDMLWrite.hh,v 1.37 2008/08/19 15:03:17 gcosmo Exp $
    28 // GEANT4 tag $Name: geant4-09-02-ref-02 $
     27// $Id: G4GDMLWrite.hh,v 1.41 2009/04/24 15:34:20 gcosmo Exp $
     28// GEANT4 tag $Name: geant4-09-03 $
    2929//
    3030//
    … …  
    4242#define _G4GDMLWRITE_INCLUDED_
    4343
    44 #include <sys/stat.h>
    45 #include <iostream>
     44#include <map>
    4645
    4746#include <xercesc/dom/DOM.hpp>
    … …  
    5049#include <xercesc/framework/LocalFileFormatTarget.hpp>
    5150
    52 #include "G4LogicalVolume.hh"
    5351#include "G4Transform3D.hh"
    54 #include "G4PVDivision.hh"
     52
     53class G4LogicalVolume;
     54class G4VPhysicalVolume;
    5555
    5656class G4GDMLWrite
    5757{
    58    typedef std::map<const G4LogicalVolume*,G4Transform3D> VolumeMapType;
    59    typedef std::map<const G4VPhysicalVolume*,G4String> PhysVolumeMapType;
    60    typedef std::map<G4int,G4int> DepthMapType;
     58  typedef std::map<const G4LogicalVolume*,G4Transform3D> VolumeMapType;
     59  typedef std::map<const G4VPhysicalVolume*,G4String> PhysVolumeMapType;
     60  typedef std::map<G4int,G4int> DepthMapType;
    6161
    62  public:  // without description
     62  public:  // with description
    6363
    64    G4Transform3D Write(const G4String& filename,
    65                        const G4LogicalVolume* const topLog,
    66                        const G4String& schemaPath,
    67                        const G4int depth, G4bool storeReferences=true);
    68    void AddModule(const G4VPhysicalVolume* const topVol);
    69    void AddModule(const G4int depth);
    70    static void SetAddPointerToName(G4bool);
     64    G4Transform3D Write(const G4String& filename,
     65                        const G4LogicalVolume* const topLog,
     66                        const G4String& schemaPath,
     67                        const G4int depth, G4bool storeReferences=true);
     68      //
     69      // Main method for writing GDML files.
    7170
    72  protected:
     71    void AddModule(const G4VPhysicalVolume* const topVol);
     72    void AddModule(const G4int depth);
     73      //
     74      // Split geometry structure in modules, by volume subtree or level
    7375
    74    G4String SchemaLocation;
     76    static void SetAddPointerToName(G4bool);
     77      //
     78      // Specify if to add or not memory addresses to IDs.
    7579
    76    VolumeMapType& VolumeMap();
     80    virtual void DefineWrite(xercesc::DOMElement*)=0;
     81    virtual void MaterialsWrite(xercesc::DOMElement*)=0;
     82    virtual void SolidsWrite(xercesc::DOMElement*)=0;
     83    virtual void StructureWrite(xercesc::DOMElement*)=0;
     84    virtual G4Transform3D TraverseVolumeTree(const G4LogicalVolume* const,
     85                                             const G4int)=0;
     86    virtual void SurfacesWrite()=0;
     87    virtual void SetupWrite(xercesc::DOMElement*,
     88                            const G4LogicalVolume* const)=0;
     89      //
     90      // Pure virtual methods implemented in concrete writer plugin's classes
    7791
    78    G4String GenerateName(const G4String&,const void* const);
    79    xercesc::DOMAttr* NewAttribute(const G4String&, const G4String&);
    80    xercesc::DOMAttr* NewAttribute(const G4String&, const G4double&);
    81    xercesc::DOMElement* NewElement(const G4String&);
    82    virtual void DefineWrite(xercesc::DOMElement*)=0;
    83    virtual void MaterialsWrite(xercesc::DOMElement*)=0;
    84    virtual void SolidsWrite(xercesc::DOMElement*)=0;
    85    virtual void StructureWrite(xercesc::DOMElement*)=0;
    86    virtual G4Transform3D TraverseVolumeTree(const G4LogicalVolume* const,
    87                                             const G4int)=0;
    88    virtual void SetupWrite(xercesc::DOMElement*,
    89                            const G4LogicalVolume* const)=0;
    90    G4String Modularize(const G4VPhysicalVolume* const topvol,
    91                        const G4int depth);
     92    virtual void ExtensionWrite(xercesc::DOMElement*);
     93    virtual void AddExtension(xercesc::DOMElement*,
     94                              const G4LogicalVolume* const);
     95      //
     96      // To be implemented in the client code for handling extensions
     97      // to the GDML schema, identified with the tag "extension".
     98      // The implementation should be placed inside a user-class
     99      // inheriting from G4GDMLWriteStructure and being registered
     100      // as argument to G4GDMLParser.
    92101
    93  private:
     102  protected:
    94103
    95    G4bool FileExists(const G4String&) const;
    96    PhysVolumeMapType& PvolumeMap();
    97    DepthMapType& DepthMap();
     104    G4GDMLWrite();
     105    virtual ~G4GDMLWrite();
    98106
    99  private:
     107    VolumeMapType& VolumeMap();
    100108
    101    static G4bool addPointerToName;
    102    xercesc::DOMDocument* doc;
    103    XMLCh tempStr[100];
     109    G4String GenerateName(const G4String&,const void* const);
     110    xercesc::DOMAttr* NewAttribute(const G4String&, const G4String&);
     111    xercesc::DOMAttr* NewAttribute(const G4String&, const G4double&);
     112    xercesc::DOMElement* NewElement(const G4String&);
     113    G4String Modularize(const G4VPhysicalVolume* const topvol,
     114                        const G4int depth);
     115
     116    G4bool FileExists(const G4String&) const;
     117    PhysVolumeMapType& PvolumeMap();
     118    DepthMapType& DepthMap();
     119
     120  protected:
     121
     122    G4String SchemaLocation;
     123    static G4bool addPointerToName;
     124    xercesc::DOMDocument* doc;
     125    xercesc::DOMElement* extElement;
     126    XMLCh tempStr[100];
    104127
    105128};

  • trunk/source/persistency/gdml/include/G4GDMLWriteDefine.hh

    r987 r1228  
    2525//
    2626//
    27 // $Id: G4GDMLWriteDefine.hh,v 1.11 2008/07/16 15:46:33 gcosmo Exp $
    28 // GEANT4 tag $Name: geant4-09-02-ref-02 $
     27// $Id: G4GDMLWriteDefine.hh,v 1.14 2009/04/24 15:34:20 gcosmo Exp $
     28// GEANT4 tag $Name: geant4-09-03 $
    2929//
    3030//
    … …  
    4242#define _G4GDMLWRITEDEFINE_INCLUDED_
    4343
     44#include "G4Types.hh"
     45#include "G4ThreeVector.hh"
     46#include "G4RotationMatrix.hh"
     47
    4448#include "G4GDMLWrite.hh"
    45 #include <sstream>
    4649
    4750class G4GDMLWriteDefine : public G4GDMLWrite
    4851{
    4952
    50  protected:
     53  public:
    5154
    52    G4ThreeVector GetAngles(const G4RotationMatrix&);
    53    void ScaleWrite(xercesc::DOMElement* element, const G4String& name,
    54                     const G4ThreeVector& scl)
    55      { Scale_vectorWrite(element,"scale",name,scl); }
    56    void RotationWrite(xercesc::DOMElement* element, const G4String& name,
    57                     const G4ThreeVector& rot)
    58      { Rotation_vectorWrite(element,"rotation",name,rot); }
    59    void PositionWrite(xercesc::DOMElement* element, const G4String& name,
    60                     const G4ThreeVector& pos)
    61      { Position_vectorWrite(element,"position",name,pos); }
    62    void FirstrotationWrite(xercesc::DOMElement* element, const G4String& name,
    63                     const G4ThreeVector& rot)
    64      { Rotation_vectorWrite(element,"firstrotation",name,rot); }
    65    void FirstpositionWrite(xercesc::DOMElement* element, const G4String& name,
    66                     const G4ThreeVector& pos)
    67      { Position_vectorWrite(element,"firstposition",name,pos); }
    68    void AddPosition(const G4String& name,
    69                     const G4ThreeVector& pos)
    70      { Position_vectorWrite(defineElement,"position",name,pos); }
     55    G4ThreeVector GetAngles(const G4RotationMatrix&);
     56    void ScaleWrite(xercesc::DOMElement* element,
     57                    const G4String& name, const G4ThreeVector& scl)
     58         { Scale_vectorWrite(element,"scale",name,scl); }
     59    void RotationWrite(xercesc::DOMElement* element,
     60                    const G4String& name, const G4ThreeVector& rot)
     61         { Rotation_vectorWrite(element,"rotation",name,rot); }
     62    void PositionWrite(xercesc::DOMElement* element,
     63                    const G4String& name, const G4ThreeVector& pos)
     64         { Position_vectorWrite(element,"position",name,pos); }
     65    void FirstrotationWrite(xercesc::DOMElement* element,
     66                    const G4String& name, const G4ThreeVector& rot)
     67         { Rotation_vectorWrite(element,"firstrotation",name,rot); }
     68    void FirstpositionWrite(xercesc::DOMElement* element,
     69                    const G4String& name, const G4ThreeVector& pos)
     70         { Position_vectorWrite(element,"firstposition",name,pos); }
     71    void AddPosition(const G4String& name, const G4ThreeVector& pos)
     72         { Position_vectorWrite(defineElement,"position",name,pos); }
    7173
    72  protected:
     74    virtual void DefineWrite(xercesc::DOMElement*);
    7375
    74    static const G4double kRelativePrecision;
    75    static const G4double kAngularPrecision;
    76    static const G4double kLinearPrecision;
     76  protected:
     77
     78    G4GDMLWriteDefine();
     79    virtual ~G4GDMLWriteDefine();
     80
     81    void Scale_vectorWrite(xercesc::DOMElement*, const G4String&,
     82                              const G4String&, const G4ThreeVector&);
     83    void Rotation_vectorWrite(xercesc::DOMElement*, const G4String&,
     84                              const G4String&, const G4ThreeVector&);
     85    void Position_vectorWrite(xercesc::DOMElement*, const G4String&,
     86                              const G4String&, const G4ThreeVector&);
     87
     88  protected:
     89
     90    static const G4double kRelativePrecision;
     91    static const G4double kAngularPrecision;
     92    static const G4double kLinearPrecision;
    7793 
    78  private:
    79 
    80    void Scale_vectorWrite(xercesc::DOMElement*, const G4String&,
    81                              const G4String&, const G4ThreeVector&);
    82    void Rotation_vectorWrite(xercesc::DOMElement*, const G4String&,
    83                              const G4String&, const G4ThreeVector&);
    84    void Position_vectorWrite(xercesc::DOMElement*, const G4String&,
    85                              const G4String&, const G4ThreeVector&);
    86    void DefineWrite(xercesc::DOMElement*);
    87 
    88  private:
    89 
    90    xercesc::DOMElement* defineElement;
     94    xercesc::DOMElement* defineElement;
    9195
    9296};

  • trunk/source/persistency/gdml/include/G4GDMLWriteMaterials.hh

    r987 r1228  
    2525//
    2626//
    27 // $Id: G4GDMLWriteMaterials.hh,v 1.12 2008/07/16 15:46:33 gcosmo Exp $
    28 // GEANT4 tag $Name: geant4-09-02-ref-02 $
     27// $Id: G4GDMLWriteMaterials.hh,v 1.17 2009/04/27 07:22:36 gcosmo Exp $
     28// GEANT4 tag $Name: geant4-09-03 $
    2929//
    3030//
    … …  
    4242#define _G4GDMLWRITEMATERIALS_INCLUDED_
    4343
    44 #include "G4Element.hh"
    45 #include "G4Isotope.hh"
    46 #include "G4Material.hh"
     44#include "G4Types.hh"
     45#include <vector>
    4746
    4847#include "G4GDMLWriteDefine.hh"
     48
     49class G4Isotope;
     50class G4Element;
     51class G4Material;
     52class G4MaterialPropertyVector;
    4953
    5054class G4GDMLWriteMaterials : public G4GDMLWriteDefine
    5155{
    5256
    53  protected:
     57 public:
    5458
    5559   void AddIsotope(const G4Isotope* const);
    … …  
    5761   void AddMaterial(const G4Material* const);
    5862
    59  private:
     63   virtual void MaterialsWrite(xercesc::DOMElement*);
     64
     65 protected:
     66
     67   G4GDMLWriteMaterials();
     68   virtual ~G4GDMLWriteMaterials();
    6069
    6170   void AtomWrite(xercesc::DOMElement*,const G4double&);
    … …  
    6675   void ElementWrite(const G4Element* const);
    6776   void MaterialWrite(const G4Material* const);
    68    void MaterialsWrite(xercesc::DOMElement*);
    69 
    70  private:
     77   void PropertyWrite(xercesc::DOMElement*, const G4Material* const);
     78   void PropertyVectorWrite(const G4String&,
     79                            const G4MaterialPropertyVector* const);
     80 protected:
    7181
    7282   std::vector<const G4Isotope*> isotopeList;

  • trunk/source/persistency/gdml/include/G4GDMLWriteParamvol.hh

    r987 r1228  
    2525//
    2626//
    27 // $Id: G4GDMLWriteParamvol.hh,v 1.10 2008/08/13 13:58:53 gcosmo Exp $
    28 // GEANT4 tag $Name: geant4-09-02-ref-02 $
     27// $Id: G4GDMLWriteParamvol.hh,v 1.13 2009/04/24 15:34:20 gcosmo Exp $
     28// GEANT4 tag $Name: geant4-09-03 $
    2929//
    3030//
    … …  
    4242#define _G4GDMLWRITEPARAMVOL_INCLUDED_
    4343
    44 #include "G4PVParameterised.hh"
    45 #include "G4VPhysicalVolume.hh"
     44#include "G4GDMLWriteSetup.hh"
    4645
    47 #include "G4GDMLWriteSetup.hh"
     46class G4Box;
     47class G4Trd;
     48class G4Trap;
     49class G4Tubs;
     50class G4Cons;
     51class G4Sphere;
     52class G4Orb;
     53class G4Torus;
     54class G4Para;
     55class G4Hype;
     56class G4VPhysicalVolume;
    4857
    4958class G4GDMLWriteParamvol : public G4GDMLWriteSetup
    5059{
    5160
     61 public:
     62
     63   virtual void ParamvolWrite(xercesc::DOMElement*,
     64                              const G4VPhysicalVolume* const);
     65   virtual void ParamvolAlgorithmWrite(xercesc::DOMElement* paramvolElement,
     66                              const G4VPhysicalVolume* const paramvol);
     67
    5268 protected:
    5369
    54    void ParamvolWrite(xercesc::DOMElement*, const G4VPhysicalVolume* const);
    55 
    56  private:
     70   G4GDMLWriteParamvol();
     71   virtual ~G4GDMLWriteParamvol();
    5772
    5873   void Box_dimensionsWrite(xercesc::DOMElement*, const G4Box* const);
    … …  
    6883   void ParametersWrite(xercesc::DOMElement*,
    6984                        const G4VPhysicalVolume* const, const G4int&);
    70    void ParamvolAlgorithmWrite(xercesc::DOMElement* paramvolElement,
    71                                const G4VPhysicalVolume* const paramvol);
    7285
    7386};

  • trunk/source/persistency/gdml/include/G4GDMLWriteSetup.hh

    r987 r1228  
    2525//
    2626//
    27 // $Id: G4GDMLWriteSetup.hh,v 1.7 2008/07/16 15:46:34 gcosmo Exp $
    28 // GEANT4 tag $Name: geant4-09-02-ref-02 $
     27// $Id: G4GDMLWriteSetup.hh,v 1.9 2009/04/15 13:29:30 gcosmo Exp $
     28// GEANT4 tag $Name: geant4-09-03 $
    2929//
    3030//
    … …  
    4646class G4GDMLWriteSetup : public G4GDMLWriteSolids
    4747{
    48  private:
     48  public:
    4949
    50    void SetupWrite(xercesc::DOMElement*, const G4LogicalVolume* const);
     50    virtual void SetupWrite(xercesc::DOMElement*, const G4LogicalVolume* const);
     51
     52 protected:
     53
     54   G4GDMLWriteSetup();
     55   virtual ~G4GDMLWriteSetup();
     56
    5157};
    5258

  • trunk/source/persistency/gdml/include/G4GDMLWriteSolids.hh

    r987 r1228  
    2525//
    2626//
    27 // $Id: G4GDMLWriteSolids.hh,v 1.32 2008/11/21 09:32:46 gcosmo Exp $
    28 // GEANT4 tag $Name: geant4-09-02-ref-02 $
     27// $Id: G4GDMLWriteSolids.hh,v 1.38 2009/04/24 15:34:20 gcosmo Exp $
     28// GEANT4 tag $Name: geant4-09-03 $
    2929//
    3030//
    … …  
    4242#define _G4GDMLWRITESOLIDS_INCLUDED_
    4343
    44 #include "G4BooleanSolid.hh"
    45 #include "G4Box.hh"
    46 #include "G4Cons.hh"
    47 #include "G4Ellipsoid.hh"
    48 #include "G4EllipticalCone.hh"
    49 #include "G4EllipticalTube.hh"
    50 #include "G4ExtrudedSolid.hh"
    51 #include "G4Hype.hh"
    52 #include "G4Orb.hh"
    53 #include "G4Para.hh"
    54 #include "G4Paraboloid.hh"
    55 #include "G4IntersectionSolid.hh"
    56 #include "G4Polycone.hh"
    57 #include "G4Polyhedra.hh"
    58 #include "G4ReflectedSolid.hh"
    59 #include "G4Sphere.hh"
    60 #include "G4SubtractionSolid.hh"
    61 #include "G4TessellatedSolid.hh"
    62 #include "G4Tet.hh"
    63 #include "G4Torus.hh"
    64 #include "G4Trap.hh"
    65 #include "G4Trd.hh"
    66 #include "G4Tubs.hh"
    67 #include "G4TwistedBox.hh"
    68 #include "G4TwistedTrap.hh"
    69 #include "G4TwistedTrd.hh"
    70 #include "G4TwistedTubs.hh"
    71 #include "G4UnionSolid.hh"
     44#include "G4Types.hh"
    7245
    7346#include "G4GDMLWriteMaterials.hh"
    7447
     48class G4BooleanSolid;
     49class G4Box;
     50class G4Cons;
     51class G4EllipticalCone;
     52class G4Ellipsoid;
     53class G4EllipticalTube;
     54class G4ExtrudedSolid;
     55class G4Hype;
     56class G4Orb;
     57class G4Para;
     58class G4Paraboloid;
     59class G4Polycone;
     60class G4Polyhedra;
     61class G4Sphere;
     62class G4TessellatedSolid;
     63class G4Tet;
     64class G4Torus;
     65class G4Trap;
     66class G4Trd;
     67class G4Tubs;
     68class G4TwistedBox;
     69class G4TwistedTrap;
     70class G4TwistedTrd;
     71class G4TwistedTubs;
     72class G4VSolid;
     73class G4OpticalSurface;
     74
    7575class G4GDMLWriteSolids : public G4GDMLWriteMaterials
    7676{
     77  public:
    7778
    78  protected:
     79   virtual void AddSolid(const G4VSolid* const);
     80   virtual void SolidsWrite(xercesc::DOMElement*);
    7981
    80    void AddSolid(const G4VSolid* const);
     82  protected:
    8183
    82  private:
     84   G4GDMLWriteSolids();
     85   virtual ~G4GDMLWriteSolids();
    8386
    8487   void BooleanWrite(xercesc::DOMElement*, const G4BooleanSolid* const);
    … …  
    108111   void ZplaneWrite(xercesc::DOMElement*, const G4double&,
    109112                    const G4double&, const G4double&);
    110    void SolidsWrite(xercesc::DOMElement*);
     113   void OpticalSurfaceWrite(xercesc::DOMElement*,
     114                    const G4OpticalSurface* const);
    111115
    112  private:
     116  protected:
    113117
    114118   std::vector<const G4VSolid*> solidList;
    115119   xercesc::DOMElement* solidsElement;
     120   static const G4int maxTransforms = 8; // Constant for limiting the number
     121                                         // of displacements/reflections
     122                                         // applied to a single solid
    116123};
    117124

  • trunk/source/persistency/gdml/include/G4GDMLWriteStructure.hh

    r987 r1228  
    2525//
    2626//
    27 // $Id: G4GDMLWriteStructure.hh,v 1.34 2008/07/16 15:46:34 gcosmo Exp $
    28 // GEANT4 tag $Name: geant4-09-02-ref-02 $
     27// $Id: G4GDMLWriteStructure.hh,v 1.39 2009/04/24 15:34:20 gcosmo Exp $
     28// GEANT4 tag $Name: geant4-09-03 $
    2929//
    3030//
    … …  
    4242#define _G4GDMLWRITESTRUCTURE_INCLUDED_
    4343
    44 #include "G4LogicalVolumeStore.hh"
    45 #include "G4PhysicalVolumeStore.hh"
    46 #include "G4Material.hh"
    47 #include "G4PVDivision.hh"
    48 #include "G4PVReplica.hh"
    49 #include "G4VPhysicalVolume.hh"
    50 #include "G4ReflectedSolid.hh"
     44#include "G4Types.hh"
    5145#include "G4Transform3D.hh"
    5246
    5347#include "G4GDMLWriteParamvol.hh"
    5448
     49class G4LogicalVolume;
     50class G4VPhysicalVolume;
     51class G4PVDivision;
     52class G4LogicalBorderSurface;
     53class G4LogicalSkinSurface;
     54class G4OpticalSurface;
     55class G4SurfaceProperty;
     56
    5557class G4GDMLWriteStructure : public G4GDMLWriteParamvol
    5658{
    5759
    58  private:
     60 public:
    5961
    60    void DivisionvolWrite(xercesc::DOMElement*,const G4PVDivision* const);
     62   G4GDMLWriteStructure();
     63   virtual ~G4GDMLWriteStructure();
     64
     65   virtual void StructureWrite(xercesc::DOMElement*);
     66
     67 protected:
     68
     69   void DivisionvolWrite(xercesc::DOMElement*, const G4PVDivision* const);
    6170   void PhysvolWrite(xercesc::DOMElement*,const G4VPhysicalVolume* const topVol,
    62                                           const G4Transform3D& transform,
    63                                           const G4String& moduleName);
    64    void ReplicavolWrite(xercesc::DOMElement*,const G4VPhysicalVolume* const);
    65    void StructureWrite(xercesc::DOMElement*);
     71                   const G4Transform3D& transform, const G4String& moduleName);
     72   void ReplicavolWrite(xercesc::DOMElement*, const G4VPhysicalVolume* const);
    6673   G4Transform3D TraverseVolumeTree(const G4LogicalVolume* const topVol,
    6774                                    const G4int depth);
    68  private:
     75   void SurfacesWrite();
     76   void BorderSurfaceCache(const G4LogicalBorderSurface* const);
     77   void SkinSurfaceCache(const G4LogicalSkinSurface* const);
     78   const G4LogicalBorderSurface* GetBorderSurface(const G4VPhysicalVolume* const);
     79   const G4LogicalSkinSurface* GetSkinSurface(const G4LogicalVolume* const);
     80   G4bool FindOpticalSurface(const G4SurfaceProperty*);
     81
     82 protected:
    6983
    7084   xercesc::DOMElement* structureElement;
    71    static const int maxReflections = 8; // Constant for limiting the number
    72                                         // of displacements/reflections applied
    73                                         // to a single solid
     85   std::vector<xercesc::DOMElement*> borderElementVec;
     86   std::vector<xercesc::DOMElement*> skinElementVec;
     87
     88 private:  // cache for optical surfaces...
     89
     90   std::vector<const G4OpticalSurface*> opt_vec;
    7491};
    7592

  • trunk/source/persistency/gdml/include/G4STRead.hh

    r987 r1228  
    2525//
    2626//
    27 // $Id: G4STRead.hh,v 1.3 2008/07/17 14:05:50 gcosmo Exp $
    28 // GEANT4 tag $Name: geant4-09-02-ref-02 $
     27// $Id: G4STRead.hh,v 1.4 2009/04/24 15:34:20 gcosmo Exp $
     28// GEANT4 tag $Name: geant4-09-03 $
    2929//
    3030//
    … …  
    4444#define _G4STREAD_INCLUDED_
    4545
    46 #include <fstream>
    4746#include <vector>
    4847#include <map>
    4948
    50 #include "G4TessellatedSolid.hh"
    51 #include "G4QuadrangularFacet.hh"
    52 #include "G4TriangularFacet.hh"
    53 #include "G4LogicalVolume.hh"
    54 #include "G4PVPlacement.hh"
    55 #include "G4Material.hh"
    56 #include "G4Box.hh"
     49#include "G4ThreeVector.hh"
     50
     51class G4Material;
     52class G4Box;
     53class G4TessellatedSolid;
     54class G4LogicalVolume;
    5755
    5856class G4STRead
Note: See TracChangeset for help on using the changeset viewer.