lars/geant4
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Import Geant4 10.0.0 source tree

Browse Source
This commit is contained in:
Gabriele Cosmo
2016-06-10 11:51:14 +02:00
parent e2d2f9810a
commit 286caacf06
12421 changed files with 730077 additions and 502383 deletions
Download Patch File Download Diff File Expand all files Collapse all files
source/persistency/gdml/CMakeLists.txt
+1 -1
View File
@@ -7,7 +7,7 @@
#
# Generated on : 24/9/2010
#
# $Id: CMakeLists.txt,v 1.1 2010-09-29 18:50:13 bmorgan Exp $
# $Id: CMakeLists.txt 66892 2013-01-17 10:57:59Z gunter $
#
#------------------------------------------------------------------------------
source/persistency/gdml/GNUmakefile
+1 -1
View File
@@ -1,4 +1,4 @@
# $Id: GNUmakefile,v 1.12 2010-11-02 10:40:24 gcosmo Exp $
# $Id: GNUmakefile 66892 2013-01-17 10:57:59Z gunter $
# -----------------------------------------------------------------------
# GNUmakefile for persistency library. Gabriele Cosmo, 16/11/96.
# -----------------------------------------------------------------------
source/persistency/gdml/History
+40 -1
View File
@@ -1,4 +1,4 @@
$Id: History,v 1.128 2010-11-30 08:56:16 gcosmo Exp $
$Id: History 77913 2013-11-29 10:59:07Z gcosmo $
-------------------------------------------------------------------
=========================================================
@@ -17,6 +17,45 @@ committal in the CVS repository !
* Reverse chronological order (last date on top), please *
----------------------------------------------------------
29 November 2013 Tatiana Nikitina (gdml-V09-06-09)
- Fixed GDML schema for spurious validation errors on last changes introduced
for parameterisation of polycone and polyhedra and multi-union.
- Fixed typo in G4GDMLReadParamvol and some code cleanup.
23 November 2013 Gabriele Cosmo (gdml-V09-06-08)
- Fixed compilation warnings on SLC5/gcc-4.1.
22 November 2013 Tatiana Nikitina (gdml-V09-06-07)
- Added support for parameterisation of polycone and polyhedra in GDML schema.
Extended related classes accordingly in reader and writer.
- Added warning in reader for multi-union structure not yet supported.
7 November 2013 Gabriele Cosmo (gdml-V09-06-06)
- Replaced deprecated calls to G4Sphere accessor methods.
29 October 2013 Tatiana Nikitina
- Added 'generic' Polycone and Polyhedra to GDML Reader and Writer.
Splitted definition of Polycone to ordinary and generic.
- Added parameterisation for Ellipsoid to readear/writer and schema.
- Added MultiUnion solid and 'generic' Polycone and Polyhedra to the schema
GDML schema updated to version 3.1.0.
- Fix in G4GDMLReadParamvol::ParametersRead() for reading parameterised
Sphere, Orb, Torus and Para.
27 August 2013 Gabriele Cosmo (gdml-V09-06-05, gdml-V09-06-04)
- Added G4Ellipsoid among solids enabled for parameterisation in
G4GDMLParameterisation.
5 June 2013 Gabriele Cosmo (gdml-V09-06-03)
- Replaced use of 'pascal' with 'hep_pascal' to avoid conflicts on Windows.
10 April 2013 Gabriele Cosmo (gdml-V09-06-02)
- Removed TLS changes in G4GDMLWrite as not necessary.
26 February 2013 Gabriele Cosmo (gdml-V09-06-01)
- Removed unused data member in G4STRead.
- Cleanup of MT changes in G4GDMLWrite.
25 October 2012 Gabriele Cosmo (gdml-V09-05-05)
- Added inclusion of headers to G4STRead.cc to make it self consistent.
source/persistency/gdml/include/G4GDMLEvaluator.hh
+1 -1
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id$
// $Id: G4GDMLEvaluator.hh 68053 2013-03-13 14:39:51Z gcosmo $
//
//
// class G4GDMLEvaluator
source/persistency/gdml/include/G4GDMLMessenger.hh
+1 -1
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id$
// $Id: G4GDMLMessenger.hh 68053 2013-03-13 14:39:51Z gcosmo $
//
//
// class G4GDMLMessenger
source/persistency/gdml/include/G4GDMLParameterisation.hh
+5 -1
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id$
// $Id: G4GDMLParameterisation.hh 77528 2013-11-25 13:06:36Z gcosmo $
//
//
// class G4GDMLParameterisation
@@ -49,6 +49,9 @@
#include "G4Cons.hh"
#include "G4Sphere.hh"
#include "G4Orb.hh"
#include "G4Ellipsoid.hh"
#include "G4Polycone.hh"
#include "G4Polyhedra.hh"
#include "G4Torus.hh"
#include "G4Para.hh"
#include "G4Hype.hh"
@@ -86,6 +89,7 @@ class G4GDMLParameterisation : public G4VPVParameterisation
void ComputeDimensions(G4Cons&,const G4int,const G4VPhysicalVolume*) const;
void ComputeDimensions(G4Sphere&,const G4int,const G4VPhysicalVolume*) const;
void ComputeDimensions(G4Orb&,const G4int,const G4VPhysicalVolume*) const;
void ComputeDimensions(G4Ellipsoid&,const G4int,const G4VPhysicalVolume*) const;
void ComputeDimensions(G4Torus&,const G4int,const G4VPhysicalVolume*) const;
void ComputeDimensions(G4Para&,const G4int,const G4VPhysicalVolume*) const;
void ComputeDimensions(G4Hype&,const G4int,const G4VPhysicalVolume*) const;
source/persistency/gdml/include/G4GDMLParser.hh
+1 -1
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id$
// $Id: G4GDMLParser.hh 68053 2013-03-13 14:39:51Z gcosmo $
//
//
// class G4GDMLParser
source/persistency/gdml/include/G4GDMLParser.icc
+1 -1
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id$
// $Id: G4GDMLParser.icc 68053 2013-03-13 14:39:51Z gcosmo $
//
//
// class G4GDMLParser inline methods
source/persistency/gdml/include/G4GDMLRead.hh
+1 -1
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id$
// $Id: G4GDMLRead.hh 68053 2013-03-13 14:39:51Z gcosmo $
//
// class G4GDMLRead
//
source/persistency/gdml/include/G4GDMLReadMaterials.hh
+1 -1
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id$
// $Id: G4GDMLReadMaterials.hh 68053 2013-03-13 14:39:51Z gcosmo $
//
//
// class G4GDMLReadMaterials
source/persistency/gdml/include/G4GDMLReadParamvol.hh
+7 -2
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id$
// $Id: G4GDMLReadParamvol.hh 77528 2013-11-25 13:06:36Z gcosmo $
//
//
// class G4GDMLReadParamvol
@@ -75,11 +75,16 @@ class G4GDMLReadParamvol : public G4GDMLReadSetup
G4GDMLParameterisation::PARAMETER&);
void Torus_dimensionsRead(const xercesc::DOMElement* const,
G4GDMLParameterisation::PARAMETER&);
void Ellipsoid_dimensionsRead(const xercesc::DOMElement* const,
G4GDMLParameterisation::PARAMETER&);
void Para_dimensionsRead(const xercesc::DOMElement* const,
G4GDMLParameterisation::PARAMETER&);
void Hype_dimensionsRead(const xercesc::DOMElement* const,
G4GDMLParameterisation::PARAMETER&);
void Polycone_dimensionsRead(const xercesc::DOMElement* const,
G4GDMLParameterisation::PARAMETER&);
void Polyhedra_dimensionsRead(const xercesc::DOMElement* const,
G4GDMLParameterisation::PARAMETER&);
void ParameterisedRead(const xercesc::DOMElement* const);
void ParametersRead(const xercesc::DOMElement* const);
source/persistency/gdml/include/G4GDMLReadSetup.hh
+1 -1
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id$
// $Id: G4GDMLReadSetup.hh 68053 2013-03-13 14:39:51Z gcosmo $
//
//
// class G4GDMLReadSetup
source/persistency/gdml/include/G4GDMLReadSolids.hh
+10 -4
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id$
// $Id: G4GDMLReadSolids.hh 77528 2013-11-25 13:06:36Z gcosmo $
//
//
// class G4GDMLReadSolids
@@ -52,8 +52,9 @@ class G4SurfaceProperty;
class G4GDMLReadSolids : public G4GDMLReadMaterials
{
enum BooleanOp {UNION,SUBTRACTION,INTERSECTION};
typedef struct { G4double rmin,rmax,z; } zplaneType;
// typedef struct { G4double rmin,rmax,z; } zplaneType;
typedef struct { G4double r,z; } rzPointType;
public:
G4VSolid* GetSolid(const G4String&) const;
@@ -62,7 +63,7 @@ class G4GDMLReadSolids : public G4GDMLReadMaterials
virtual void SolidsRead(const xercesc::DOMElement* const);
protected:
typedef struct { G4double rmin,rmax,z; } zplaneType;
G4GDMLReadSolids();
virtual ~G4GDMLReadSolids();
@@ -74,11 +75,14 @@ class G4GDMLReadSolids : public G4GDMLReadMaterials
void EltubeRead(const xercesc::DOMElement* const);
void XtruRead(const xercesc::DOMElement* const);
void HypeRead(const xercesc::DOMElement* const);
void MultiUnionRead(const xercesc::DOMElement* const);
void OrbRead(const xercesc::DOMElement* const);
void ParaRead(const xercesc::DOMElement* const);
void ParaboloidRead(const xercesc::DOMElement* const);
void PolyconeRead(const xercesc::DOMElement* const);
void GenericPolyconeRead(const xercesc::DOMElement* const);
void PolyhedraRead(const xercesc::DOMElement* const);
void GenericPolyhedraRead(const xercesc::DOMElement* const);
G4QuadrangularFacet* QuadrangularRead(const xercesc::DOMElement* const);
void ReflectedSolidRead(const xercesc::DOMElement* const);
G4ExtrudedSolid::ZSection SectionRead(const xercesc::DOMElement* const,G4double);
@@ -98,7 +102,9 @@ class G4GDMLReadSolids : public G4GDMLReadMaterials
G4TriangularFacet* TriangularRead(const xercesc::DOMElement* const);
G4TwoVector TwoDimVertexRead(const xercesc::DOMElement* const,G4double);
zplaneType ZplaneRead(const xercesc::DOMElement* const);
rzPointType RZPointRead(const xercesc::DOMElement* const);
void OpticalSurfaceRead(const xercesc::DOMElement* const);
};
#endif
source/persistency/gdml/include/G4GDMLReadStructure.hh
+1 -1
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id$
// $Id: G4GDMLReadStructure.hh 68053 2013-03-13 14:39:51Z gcosmo $
//
//
// class G4GDMLReadStructure
source/persistency/gdml/include/G4GDMLWrite.hh
+1 -1
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id$
// $Id: G4GDMLWrite.hh 69013 2013-04-15 09:41:13Z gcosmo $
//
//
// class G4GDMLWrite
source/persistency/gdml/include/G4GDMLWriteDefine.hh
+1 -1
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id$
// $Id: G4GDMLWriteDefine.hh 68053 2013-03-13 14:39:51Z gcosmo $
//
//
// class G4GDMLWriteDefine
source/persistency/gdml/include/G4GDMLWriteMaterials.hh
+1 -1
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id$
// $Id: G4GDMLWriteMaterials.hh 68053 2013-03-13 14:39:51Z gcosmo $
//
//
// class G4GDMLWriteMaterials
source/persistency/gdml/include/G4GDMLWriteParamvol.hh
+7 -1
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id$
// $Id: G4GDMLWriteParamvol.hh 77528 2013-11-25 13:06:36Z gcosmo $
//
//
// class G4GDMLWriteParamvol
@@ -50,8 +50,11 @@ class G4Cons;
class G4Sphere;
class G4Orb;
class G4Torus;
class G4Ellipsoid;
class G4Para;
class G4Hype;
class G4Polycone;
class G4Polyhedra;
class G4VPhysicalVolume;
class G4GDMLWriteParamvol : public G4GDMLWriteSetup
@@ -77,8 +80,11 @@ class G4GDMLWriteParamvol : public G4GDMLWriteSetup
void Sphere_dimensionsWrite(xercesc::DOMElement*, const G4Sphere* const);
void Orb_dimensionsWrite(xercesc::DOMElement*, const G4Orb* const);
void Torus_dimensionsWrite(xercesc::DOMElement*, const G4Torus* const);
void Ellipsoid_dimensionsWrite(xercesc::DOMElement*, const G4Ellipsoid* const);
void Para_dimensionsWrite(xercesc::DOMElement*, const G4Para* const);
void Hype_dimensionsWrite(xercesc::DOMElement*, const G4Hype* const);
void Polycone_dimensionsWrite(xercesc::DOMElement*, const G4Polycone* const);
void Polyhedra_dimensionsWrite(xercesc::DOMElement*, const G4Polyhedra* const);
void ParametersWrite(xercesc::DOMElement*,
const G4VPhysicalVolume* const, const G4int&);
source/persistency/gdml/include/G4GDMLWriteSetup.hh
+1 -1
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id$
// $Id: G4GDMLWriteSetup.hh 68053 2013-03-13 14:39:51Z gcosmo $
//
//
// class G4GDMLWriteSetup
source/persistency/gdml/include/G4GDMLWriteSolids.hh
+4 -1
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id$
// $Id: G4GDMLWriteSolids.hh 76271 2013-11-08 11:51:39Z gcosmo $
//
//
// class G4GDMLWriteSolids
@@ -56,6 +56,7 @@ class G4Orb;
class G4Para;
class G4Paraboloid;
class G4Polycone;
class G4GenericPolycone;
class G4Polyhedra;
class G4Sphere;
class G4TessellatedSolid;
@@ -97,6 +98,7 @@ class G4GDMLWriteSolids : public G4GDMLWriteMaterials
void ParaWrite(xercesc::DOMElement*, const G4Para* const);
void ParaboloidWrite(xercesc::DOMElement*, const G4Paraboloid* const);
void PolyconeWrite(xercesc::DOMElement*, const G4Polycone* const);
void GenericPolyconeWrite(xercesc::DOMElement*, const G4GenericPolycone* const);
void PolyhedraWrite(xercesc::DOMElement*, const G4Polyhedra* const);
void SphereWrite(xercesc::DOMElement*, const G4Sphere* const);
void TessellatedWrite(xercesc::DOMElement*, const G4TessellatedSolid* const);
@@ -113,6 +115,7 @@ class G4GDMLWriteSolids : public G4GDMLWriteMaterials
void TwistedtubsWrite(xercesc::DOMElement*, const G4TwistedTubs* const);
void ZplaneWrite(xercesc::DOMElement*, const G4double&,
const G4double&, const G4double&);
void RZPointWrite(xercesc::DOMElement*, const G4double&,const G4double&);
void OpticalSurfaceWrite(xercesc::DOMElement*,
const G4OpticalSurface* const);
source/persistency/gdml/include/G4GDMLWriteStructure.hh
+1 -1
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id$
// $Id: G4GDMLWriteStructure.hh 68053 2013-03-13 14:39:51Z gcosmo $
//
//
// class G4GDMLWriteStructure
source/persistency/gdml/include/G4STRead.hh
+1 -2
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id$
// $Id: G4STRead.hh 68053 2013-03-13 14:39:51Z gcosmo $
//
//
// class G4STRead
@@ -71,7 +71,6 @@ class G4STRead
G4Box* world_box;
G4ThreeVector world_extent;
G4Material* solid_material;
G4Material* medium_material;
G4LogicalVolume* world_volume;
std::vector<G4TessellatedSolid*> tessellatedList;
std::map<G4TessellatedSolid*,G4LogicalVolume*> volumeMap;
source/persistency/gdml/schema/gdml_parameterised.xsd
+69
View File
@@ -167,6 +167,24 @@
<!-- ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
<xs:element name="torus_dimensions" substitutionGroup="Dimensions" type="TorusDimensionsType"/>
<!-- ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
<xs:complexType name="EllipsoidDimensionsType">
<xs:annotation>
<xs:documentation>Dimensions for parametrised Ellipsoid. </xs:documentation>
</xs:annotation>
<xs:complexContent>
<xs:extension base="DimensionsType">
<xs:attribute default="1.0" name="ax" type="ExpressionOrIDREFType"></xs:attribute>
<xs:attribute default="1.0" name="by" type="ExpressionOrIDREFType"></xs:attribute>
<xs:attribute default="1.0" name="cz" type="ExpressionOrIDREFType"></xs:attribute>
<xs:attribute default="-1000000.0" name="zcut1" type="ExpressionOrIDREFType"></xs:attribute>
<xs:attribute default="1000000.0" name="zcut2" type="ExpressionOrIDREFType"></xs:attribute>
<xs:attribute default="mm" name="lunit" type="xs:string"></xs:attribute>
</xs:extension>
</xs:complexContent>
</xs:complexType>
<!-- ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
<xs:element name="ellipsoid_dimensions" substitutionGroup="Dimensions" type="EllipsoidDimensionsType"/>
<!-- ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
<xs:complexType name="ParaDimensionsType">
<xs:annotation>
<xs:documentation>Dimensions for parametrised Paras. </xs:documentation>
@@ -187,7 +205,58 @@
<!-- ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
<xs:element name="para_dimensions" substitutionGroup="Dimensions" type="ParaDimensionsType"/>
<!-- ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
<xs:complexType name="PolyconeDimensionsType">
<xs:annotation>
<xs:documentation>Dimensions for parametrised Polycone. </xs:documentation>
</xs:annotation>
<xs:complexContent>
<xs:extension base="DimensionsType">
<xs:sequence>
<xs:element name="zplane" minOccurs="1" maxOccurs="unbounded" type="ZPlaneType"/>
</xs:sequence>
<xs:attribute default="1.0" name="numRZ" type="ExpressionOrIDREFType"></xs:attribute>
<xs:attribute default="0.0" name="startPhi" type="ExpressionOrIDREFType"></xs:attribute>
<xs:attribute default="1.0" name="openPhi" type="ExpressionOrIDREFType"></xs:attribute>
<xs:attribute default="mm" name="lunit" type="xs:string"></xs:attribute>
<xs:attribute default="radian" name="aunit" type="xs:string"></xs:attribute>
</xs:extension>
</xs:complexContent>
</xs:complexType>
<!-- ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
<xs:element name="polycone_dimensions" substitutionGroup="Dimensions" type="PolyconeDimensionsType"/>
<!-- ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
<xs:complexType name="PolyhedraDimensionsType">
<xs:annotation>
<xs:documentation>Dimensions for parametrised Polyhedra. </xs:documentation>
</xs:annotation>
<xs:complexContent>
<xs:extension base="DimensionsType">
<xs:sequence>
<xs:element name="zplane" minOccurs="1" maxOccurs="unbounded" type="ZPlaneParamType"/>
</xs:sequence>
<xs:attribute default="1.0" name="numRZ" type="ExpressionOrIDREFType"></xs:attribute>
<xs:attribute default="1.0" name="numSide" type="ExpressionOrIDREFType"></xs:attribute>
<xs:attribute default="1.0" name="startPhi" type="ExpressionOrIDREFType"></xs:attribute>
<xs:attribute default="1.0" name="openPhi" type="ExpressionOrIDREFType"></xs:attribute>
<xs:attribute default="mm" name="lunit" type="xs:string"></xs:attribute>
<xs:attribute default="radian" name="aunit" type="xs:string"></xs:attribute>
</xs:extension>
</xs:complexContent>
</xs:complexType>
<!-- ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
<xs:element name="polyhedra_dimensions" substitutionGroup="Dimensions" type="PolyhedraDimensionsType"/>
<!-- ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
<!-- ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
<xs:complexType name="ZPlaneParamType">
<xs:attribute default="0.0" name="z" type="ExpressionOrIDREFType" ></xs:attribute>
<xs:attribute default="0.0" name="rmin" type="ExpressionOrIDREFType"></xs:attribute>
<xs:attribute default="1.0" name="rmax" type="ExpressionOrIDREFType" ></xs:attribute>
</xs:complexType>
<!-- ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
<xs:complexType name="HypeDimensionsType">
<!-- ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
<xs:annotation>
<xs:documentation>Dimensions for parametrised Hypes. </xs:documentation>
</xs:annotation>
source/persistency/gdml/schema/gdml_solids.xsd
+97
View File
@@ -53,6 +53,50 @@
</xs:extension>
</xs:complexContent>
</xs:complexType>
<!-- ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
<xs:complexType name="multiUnionNode">
<xs:annotation>
<xs:documentation>Base node for Multi-Union structure</xs:documentation>
</xs:annotation>
<xs:complexContent>
<xs:extension base="SolidType">
<xs:sequence>
<xs:choice minOccurs="0">
<xs:element name="position" type="positionType"></xs:element>
<xs:element name="positionref" type="ReferenceType"></xs:element>
</xs:choice>
<xs:choice minOccurs="0">
<xs:element name="rotation" type="rotationType"></xs:element>
<xs:element name="rotationref" type="ReferenceType"></xs:element>
</xs:choice>
</xs:sequence>
<xs:attribute name="solid" type="ExpressionOrIDREFType" use="required"></xs:attribute>
</xs:extension>
</xs:complexContent>
</xs:complexType>
<!-- ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
<xs:element name="multiUnion" substitutionGroup="Solid">
<xs:annotation>
<xs:documentation>MultiUnion is a Solid created by Union of many Solids.
This Solid is constructed by multiUnionNodes;
each Node is described by solid with its position and rotation.
</xs:documentation>
</xs:annotation>
<xs:complexType>
<xs:complexContent>
<xs:extension base="SolidType">
<xs:sequence>
<xs:element name="node" minOccurs="1" maxOccurs="unbounded" type="multiUnionNode"/>
</xs:sequence>
</xs:extension>
</xs:complexContent>
</xs:complexType>
</xs:element>
<!-- ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
<xs:element name="reflectedSolid" substitutionGroup="Solid">
@@ -474,6 +518,35 @@
<xs:attribute default="0.0" name="rmin" type="ExpressionOrIDREFType"></xs:attribute>
<xs:attribute name="rmax" type="ExpressionOrIDREFType" use="required"></xs:attribute>
</xs:complexType>
<!-- ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
<xs:element name="genericPolycone" substitutionGroup="Solid">
<xs:annotation>
<xs:documentation>Generic polycone or polycone segment described by
startphi starting angle of the segment in radians
deltaphi delta angle of the segment in radians
and a set of points with (r,z)coordinates
</xs:documentation>
</xs:annotation>
<xs:complexType>
<xs:complexContent>
<xs:extension base="SolidType">
<xs:sequence>
<xs:element name="rzpoint" minOccurs="3" maxOccurs="unbounded" type="RZPointType"/>
</xs:sequence>
<xs:attribute name="deltaphi" type="ExpressionOrIDREFType" use="required"></xs:attribute>
<xs:attribute default="0.0" name="startphi" type="ExpressionOrIDREFType"></xs:attribute>
</xs:extension>
</xs:complexContent>
</xs:complexType>
</xs:element>
<!-- +++++++++++++ -->
<xs:complexType name="RZPointType">
<xs:attribute name="r" type="ExpressionOrIDREFType" use="required"></xs:attribute>
<xs:attribute name="z" type="ExpressionOrIDREFType" use="required"></xs:attribute>
</xs:complexType>
<!-- ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
<xs:element name="para" substitutionGroup="Solid">
@@ -621,6 +694,30 @@
</xs:element>
<!-- ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
<xs:element name="genericPolyhedra" substitutionGroup="Solid">
<xs:annotation>
<xs:documentation>Polyhedra is described by
startphi initial phi starting angle
totalphi total phi angle
numsides number sides
and a set of points with (r,z) coordinates.</xs:documentation>
</xs:annotation>
<xs:complexType>
<xs:complexContent>
<xs:extension base="SolidType">
<xs:sequence>
<xs:element name="rzpoint" minOccurs="3" maxOccurs="unbounded" type="RZPointType"/>
</xs:sequence>
<xs:attribute name="startphi" type="ExpressionOrIDREFType" use="required"></xs:attribute>
<xs:attribute name="deltaphi" type="ExpressionOrIDREFType" use="required"></xs:attribute>
<xs:attribute name="numsides" type="ExpressionOrIDREFType" use="required"></xs:attribute>
</xs:extension>
</xs:complexContent>
</xs:complexType>
</xs:element>
<!-- ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
<xs:complexType name="TwoDimVertexType">
<xs:attribute name="x" type="ExpressionOrIDREFType" use="required"></xs:attribute>
<xs:attribute name="y" type="ExpressionOrIDREFType" use="required"></xs:attribute>
source/persistency/gdml/sources.cmake
+1 -1
View File
@@ -11,7 +11,7 @@
#
# Generated on : 24/9/2010
#
# $Id: sources.cmake,v 1.2 2010-11-02 10:40:06 gcosmo Exp $
# $Id: sources.cmake 66892 2013-01-17 10:57:59Z gunter $
#
#------------------------------------------------------------------------------
source/persistency/gdml/src/G4GDMLEvaluator.cc
+1 -1
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id$
// $Id: G4GDMLEvaluator.cc 68053 2013-03-13 14:39:51Z gcosmo $
// GEANT4 tag $ Name:$
//
// class G4GDMLEvaluator Implementation
source/persistency/gdml/src/G4GDMLMessenger.cc
+1 -1
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id$
// $Id: G4GDMLMessenger.cc 68053 2013-03-13 14:39:51Z gcosmo $
//
//
// class G4GDMLMessenger Implementation
source/persistency/gdml/src/G4GDMLParameterisation.cc
+51 -10
View File
@@ -23,7 +23,7 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id$
// $Id: G4GDMLParameterisation.cc 77556 2013-11-26 08:56:14Z gcosmo $
//
// class G4GDMLParameterisation Implementation
//
@@ -32,6 +32,8 @@
// -------------------------------------------------------------------------
#include "G4GDMLParameterisation.hh"
#include "G4PolyconeHistorical.hh"
#include "G4PolyhedraHistorical.hh"
G4int G4GDMLParameterisation::GetSize() const
{
@@ -109,7 +111,7 @@ ComputeDimensions(G4Cons& cons,const G4int index,const G4VPhysicalVolume*) const
void G4GDMLParameterisation::
ComputeDimensions(G4Sphere& sphere,const G4int index,const G4VPhysicalVolume*) const
{
sphere.SetInsideRadius(parameterList[index].dimension[0]);
sphere.SetInnerRadius(parameterList[index].dimension[0]);
sphere.SetOuterRadius(parameterList[index].dimension[1]);
sphere.SetStartPhiAngle(parameterList[index].dimension[2]);
sphere.SetDeltaPhiAngle(parameterList[index].dimension[3]);
@@ -123,6 +125,16 @@ ComputeDimensions(G4Orb& orb,const G4int index,const G4VPhysicalVolume*) const
orb.SetRadius(parameterList[index].dimension[0]);
}
void G4GDMLParameterisation::
ComputeDimensions(G4Ellipsoid& ellipsoid,const G4int index,const G4VPhysicalVolume*) const
{
ellipsoid.SetSemiAxis(parameterList[index].dimension[0],
parameterList[index].dimension[1],
parameterList[index].dimension[2]);
ellipsoid.SetZCuts(parameterList[index].dimension[3],
parameterList[index].dimension[4]);
}
void G4GDMLParameterisation::
ComputeDimensions(G4Torus& torus,const G4int index,const G4VPhysicalVolume*) const
{
@@ -155,17 +167,46 @@ ComputeDimensions(G4Hype& hype,const G4int index,const G4VPhysicalVolume*) const
}
void G4GDMLParameterisation::
ComputeDimensions(G4Polycone&,const G4int,const G4VPhysicalVolume*) const
ComputeDimensions(G4Polycone& pcone,const G4int index,const G4VPhysicalVolume*) const
{
G4Exception("G4GDMLParameterisation::ComputeDimensions()",
"InvalidSetup", FatalException,
"Parameterisation of G4Polycone not implemented yet. Sorry!");
G4PolyconeHistorical origparam( *(pcone.GetOriginalParameters()) );
origparam.Start_angle = parameterList[index].dimension[0];
origparam.Opening_angle = parameterList[index].dimension[1];
origparam.Num_z_planes = (G4int) parameterList[index].dimension[2];
G4int nZplanes = origparam.Num_z_planes;
for( G4int ii = 0; ii < nZplanes; ii++ )
{
origparam.Rmin[ii] = parameterList[index].dimension[3+ii*3] ;
origparam.Rmax[ii] = parameterList[index].dimension[4+ii*3] ;
origparam.Z_values[ii] = parameterList[index].dimension[5+ii*3] ;
}
pcone.SetOriginalParameters(&origparam); // copy values & transfer pointers
pcone.Reset(); // reset to new solid parameters
}
void G4GDMLParameterisation::
ComputeDimensions(G4Polyhedra&,const G4int,const G4VPhysicalVolume*) const
ComputeDimensions(G4Polyhedra& polyhedra,const G4int index,const G4VPhysicalVolume*) const
{
G4Exception("G4GDMLParameterisation::ComputeDimensions()",
"InvalidSetup", FatalException,
"Parameterisation of G4Polyhedra not implemented yet. Sorry!");
G4PolyhedraHistorical origparam( *(polyhedra.GetOriginalParameters()) );
origparam.Start_angle = parameterList[index].dimension[0];
origparam.Opening_angle = parameterList[index].dimension[1];
origparam.Num_z_planes = (G4int) parameterList[index].dimension[2];
origparam.numSide = (G4int) parameterList[index].dimension[3];
G4int nZplanes = origparam.Num_z_planes;
for( G4int ii = 0; ii < nZplanes; ii++ )
{
origparam.Rmin[ii] = parameterList[index].dimension[4+ii*3] ;
origparam.Rmax[ii] = parameterList[index].dimension[5+ii*3] ;
origparam.Z_values[ii] = parameterList[index].dimension[6+ii*3] ;
}
polyhedra.SetOriginalParameters(&origparam); // copy values & transfer pointers
polyhedra.Reset(); // reset to new solid parameters
}
source/persistency/gdml/src/G4GDMLParser.cc
+1 -1
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id$
// $Id: G4GDMLParser.cc 68053 2013-03-13 14:39:51Z gcosmo $
//
//
// class G4GDMLParser Implementation
source/persistency/gdml/src/G4GDMLRead.cc
+1 -1
View File
@@ -23,7 +23,7 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id$
// $Id: G4GDMLRead.cc 68053 2013-03-13 14:39:51Z gcosmo $
//
// class G4GDMLRead Implementation
//
source/persistency/gdml/src/G4GDMLReadDefine.cc
+1 -1
View File
@@ -23,7 +23,7 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id$
// $Id: G4GDMLReadDefine.cc 68053 2013-03-13 14:39:51Z gcosmo $
//
// class G4GDMLReadDefine Implementation
//
source/persistency/gdml/src/G4GDMLReadMaterials.cc
+2 -2
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id$
// $Id: G4GDMLReadMaterials.cc 70764 2013-06-05 12:54:37Z gcosmo $
// GEANT4 tag $ Name:$
//
// class G4GDMLReadMaterials Implementation
@@ -159,7 +159,7 @@ G4double G4GDMLReadMaterials::DRead(const xercesc::DOMElement* const DElement)
G4double G4GDMLReadMaterials::PRead(const xercesc::DOMElement* const PElement)
{
G4double value = STP_Pressure;
G4double unit = pascal;
G4double unit = hep_pascal;
const xercesc::DOMNamedNodeMap* const attributes = PElement->getAttributes();
XMLSize_t attributeCount = attributes->getLength();
source/persistency/gdml/src/G4GDMLReadParamvol.cc
+206 -8
View File
@@ -23,7 +23,7 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id$
// $Id: G4GDMLReadParamvol.cc 77913 2013-11-29 10:59:07Z gcosmo $
//
// class G4GDMLReadParamvol Implementation
//
@@ -32,7 +32,7 @@
// -------------------------------------------------------------------------
#include "G4GDMLReadParamvol.hh"
#include "G4GDMLReadSolids.hh"
#include "G4LogicalVolume.hh"
#include "G4PVParameterised.hh"
#include "G4PVPlacement.hh"
@@ -451,6 +451,54 @@ Torus_dimensionsRead( const xercesc::DOMElement* const element,
parameter.dimension[4] *= aunit;
}
void G4GDMLReadParamvol::
Ellipsoid_dimensionsRead( const xercesc::DOMElement* const element,
G4GDMLParameterisation::PARAMETER& parameter )
{
G4double lunit = 1.0;
const xercesc::DOMNamedNodeMap* const attributes = element->getAttributes();
XMLSize_t attributeCount = attributes->getLength();
for (XMLSize_t attribute_index=0;
attribute_index<attributeCount; attribute_index++)
{
xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
{ continue; }
const xercesc::DOMAttr* const attribute
= dynamic_cast<xercesc::DOMAttr*>(attribute_node);
if (!attribute)
{
G4Exception("G4GDMLReadParamvol::Ellipsoid_dimensionsRead()",
"InvalidRead", FatalException, "No attribute found!");
return;
}
const G4String attName = Transcode(attribute->getName());
const G4String attValue = Transcode(attribute->getValue());
if (attName=="lunit")
{ lunit = eval.Evaluate(attValue); } else
if (attName=="ax")
{ parameter.dimension[0] = eval.Evaluate(attValue); } else
if (attName=="by")
{ parameter.dimension[1] = eval.Evaluate(attValue); } else
if (attName=="cz")
{ parameter.dimension[2] = eval.Evaluate(attValue); } else
if (attName=="zcut1")
{ parameter.dimension[3] = eval.Evaluate(attValue); } else
if (attName=="zcut2")
{ parameter.dimension[4] = eval.Evaluate(attValue); }
}
parameter.dimension[0] *= lunit;
parameter.dimension[1] *= lunit;
parameter.dimension[2] *= lunit;
parameter.dimension[3] *= lunit;
parameter.dimension[4] *= lunit;
}
void G4GDMLReadParamvol::
Para_dimensionsRead( const xercesc::DOMElement* const element,
G4GDMLParameterisation::PARAMETER& parameter )
@@ -559,8 +607,156 @@ Hype_dimensionsRead( const xercesc::DOMElement* const element,
}
void G4GDMLReadParamvol::
ParametersRead(const xercesc::DOMElement* const element) {
Polycone_dimensionsRead( const xercesc::DOMElement* const element,
G4GDMLParameterisation::PARAMETER& parameter )
{
G4double lunit = 1.0;
G4double aunit = 1.0;
std::vector<zplaneType> zplaneList;
const xercesc::DOMNamedNodeMap* const attributes = element->getAttributes();
XMLSize_t attributeCount = attributes->getLength();
for (XMLSize_t attribute_index=0;
attribute_index<attributeCount; attribute_index++)
{
xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
{ continue; }
const xercesc::DOMAttr* const attribute
= dynamic_cast<xercesc::DOMAttr*>(attribute_node);
if (!attribute)
{
G4Exception("G4GDMLReadParamvol::Polycone_dimensionsRead()",
"InvalidRead", FatalException, "No attribute found!");
return;
}
const G4String attName = Transcode(attribute->getName());
const G4String attValue = Transcode(attribute->getValue());
if (attName=="lunit")
{ lunit = eval.Evaluate(attValue); } else
if (attName=="aunit")
{ aunit = eval.Evaluate(attValue); } else
if (attName=="startPhi")
{ parameter.dimension[0] = eval.Evaluate(attValue); } else
if (attName=="openPhi")
{ parameter.dimension[1] = eval.Evaluate(attValue); } else
if (attName=="numRZ")
{ parameter.dimension[2] = eval.Evaluate(attValue); }
}
parameter.dimension[0] *= aunit;
parameter.dimension[1] *= aunit;
for (xercesc::DOMNode* iter = element->getFirstChild();
iter != 0; iter = iter->getNextSibling())
{
if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE) { continue; }
const xercesc::DOMElement* const child
= dynamic_cast<xercesc::DOMElement*>(iter);
if (!child)
{
G4Exception("G4GDMLReadParamVol::Polycone_dimensionsRead()",
"InvalidRead", FatalException, "No child found!");
return;
}
const G4String tag = Transcode(child->getTagName());
if (tag=="zplane") { zplaneList.push_back(ZplaneRead(child)); }
}
G4int numZPlanes = zplaneList.size();
for (G4int i=0; i<numZPlanes; i++)
{
parameter.dimension[3+i*3] = zplaneList[i].rmin*lunit;
parameter.dimension[4+i*3] = zplaneList[i].rmax*lunit;
parameter.dimension[5+i*3] = zplaneList[i].z*lunit;
}
}
void G4GDMLReadParamvol::
Polyhedra_dimensionsRead( const xercesc::DOMElement* const element,
G4GDMLParameterisation::PARAMETER& parameter )
{
G4double lunit = 1.0;
G4double aunit = 1.0;
std::vector<zplaneType> zplaneList;
const xercesc::DOMNamedNodeMap* const attributes = element->getAttributes();
XMLSize_t attributeCount = attributes->getLength();
for (XMLSize_t attribute_index=0;
attribute_index<attributeCount; attribute_index++)
{
xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
{ continue; }
const xercesc::DOMAttr* const attribute
= dynamic_cast<xercesc::DOMAttr*>(attribute_node);
if (!attribute)
{
G4Exception("G4GDMLReadParamvol::Polycone_dimensionsRead()",
"InvalidRead", FatalException, "No attribute found!");
return;
}
const G4String attName = Transcode(attribute->getName());
const G4String attValue = Transcode(attribute->getValue());
if (attName=="lunit")
{ lunit = eval.Evaluate(attValue); } else
if (attName=="aunit")
{ aunit = eval.Evaluate(attValue); } else
if (attName=="startPhi")
{ parameter.dimension[0] = eval.Evaluate(attValue); } else
if (attName=="openPhi")
{ parameter.dimension[1] = eval.Evaluate(attValue); } else
if (attName=="numRZ")
{ parameter.dimension[2] = eval.Evaluate(attValue); } else
if (attName=="numSide")
{ parameter.dimension[3] = eval.Evaluate(attValue); }
}
parameter.dimension[0] *= aunit;
parameter.dimension[1] *= aunit;
for (xercesc::DOMNode* iter = element->getFirstChild();
iter != 0; iter = iter->getNextSibling())
{
if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE) { continue; }
const xercesc::DOMElement* const child
= dynamic_cast<xercesc::DOMElement*>(iter);
if (!child)
{
G4Exception("G4GDMLReadParamvo::PolyhedraRead()",
"InvalidRead", FatalException, "No child found!");
return;
}
const G4String tag = Transcode(child->getTagName());
if (tag=="zplane") { zplaneList.push_back(ZplaneRead(child)); }
}
G4int numZPlanes = zplaneList.size();
for (G4int i=0; i<numZPlanes; i++)
{
parameter.dimension[4+i*3] = zplaneList[i].rmin*lunit;
parameter.dimension[5+i*3] = zplaneList[i].rmax*lunit;
parameter.dimension[6+i*3] = zplaneList[i].z*lunit;
}
}
void G4GDMLReadParamvol::
ParametersRead(const xercesc::DOMElement* const element)
{
G4ThreeVector rotation(0.0,0.0,0.0);
G4ThreeVector position(0.0,0.0,0.0);
@@ -591,10 +787,13 @@ ParametersRead(const xercesc::DOMElement* const element) {
if (tag=="trap_dimensions") { Trap_dimensionsRead(child,parameter); } else
if (tag=="tube_dimensions") { Tube_dimensionsRead(child,parameter); } else
if (tag=="cone_dimensions") { Cone_dimensionsRead(child,parameter); } else
if (tag=="sphere_dimensions") { Cone_dimensionsRead(child,parameter); } else
if (tag=="orb_dimensions") { Cone_dimensionsRead(child,parameter); } else
if (tag=="torus_dimensions") { Cone_dimensionsRead(child,parameter); } else
if (tag=="para_dimensions") { Cone_dimensionsRead(child,parameter); } else
if (tag=="sphere_dimensions") { Sphere_dimensionsRead(child,parameter); } else
if (tag=="orb_dimensions") { Orb_dimensionsRead(child,parameter); } else
if (tag=="torus_dimensions") { Torus_dimensionsRead(child,parameter); } else
if (tag=="ellipsoid_dimensions") { Ellipsoid_dimensionsRead(child,parameter); } else
if (tag=="para_dimensions") { Para_dimensionsRead(child,parameter); } else
if (tag=="polycone_dimensions") { Polycone_dimensionsRead(child,parameter); } else
if (tag=="polyhedra_dimensions") { Polyhedra_dimensionsRead(child,parameter); } else
if (tag=="hype_dimensions") { Hype_dimensionsRead(child,parameter); }
else
{
@@ -696,7 +895,6 @@ ParamvolRead(const xercesc::DOMElement* const element, G4LogicalVolume* mother)
G4String volumeref;
parameterisation = new G4GDMLParameterisation();
for (xercesc::DOMNode* iter = element->getFirstChild();
iter != 0; iter = iter->getNextSibling())
{
source/persistency/gdml/src/G4GDMLReadSetup.cc
+1 -1
View File
@@ -23,7 +23,7 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id$
// $Id: G4GDMLReadSetup.cc 68053 2013-03-13 14:39:51Z gcosmo $
//
// class G4GDMLReadSetup Implementation
//
source/persistency/gdml/src/G4GDMLReadSolids.cc
+203 -2
View File
@@ -23,7 +23,7 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id$
// $Id: G4GDMLReadSolids.cc 77528 2013-11-25 13:06:36Z gcosmo $
//
// class G4GDMLReadSolids Implementation
//
@@ -32,7 +32,6 @@
// --------------------------------------------------------------------
#include "G4GDMLReadSolids.hh"
#include "G4Box.hh"
#include "G4Cons.hh"
#include "G4Ellipsoid.hh"
@@ -44,6 +43,7 @@
#include "G4Para.hh"
#include "G4Paraboloid.hh"
#include "G4Polycone.hh"
#include "G4GenericPolycone.hh"
#include "G4Polyhedra.hh"
#include "G4QuadrangularFacet.hh"
#include "G4ReflectedSolid.hh"
@@ -535,6 +535,13 @@ void G4GDMLReadSolids::HypeRead(const xercesc::DOMElement* const hypeElement)
new G4Hype(name,rmin,rmax,inst,outst,z);
}
void G4GDMLReadSolids::MultiUnionRead(const xercesc::DOMElement* const)
{
G4Exception("G4GDMLReadSolids::MultiUnionRead()",
"InvalidSetup", JustWarning,
"MultiUnion is not supported yet. Sorry!");
}
void G4GDMLReadSolids::OrbRead(const xercesc::DOMElement* const orbElement)
{
G4String name;
@@ -755,6 +762,82 @@ PolyconeRead(const xercesc::DOMElement* const polyconeElement)
z_array,rmin_array,rmax_array);
}
void G4GDMLReadSolids::
GenericPolyconeRead(const xercesc::DOMElement* const polyconeElement)
{
G4String name;
G4double lunit = 1.0;
G4double aunit = 1.0;
G4double startphi = 0.0;
G4double deltaphi = 0.0;
const xercesc::DOMNamedNodeMap* const attributes
= polyconeElement->getAttributes();
XMLSize_t attributeCount = attributes->getLength();
for (XMLSize_t attribute_index=0;
attribute_index<attributeCount; attribute_index++)
{
xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
{ continue; }
const xercesc::DOMAttr* const attribute
= dynamic_cast<xercesc::DOMAttr*>(attribute_node);
if (!attribute)
{
G4Exception("G4GDMLReadSolids::GenericPolyconeRead()",
"InvalidRead", FatalException, "No attribute found!");
return;
}
const G4String attName = Transcode(attribute->getName());
const G4String attValue = Transcode(attribute->getValue());
if (attName=="name") { name = GenerateName(attValue); } else
if (attName=="lunit") { lunit = eval.Evaluate(attValue); } else
if (attName=="aunit") { aunit = eval.Evaluate(attValue); } else
if (attName=="startphi") { startphi = eval.Evaluate(attValue); }else
if (attName=="deltaphi") { deltaphi = eval.Evaluate(attValue); }
}
startphi *= aunit;
deltaphi *= aunit;
std::vector<rzPointType> rzPointList;
for (xercesc::DOMNode* iter = polyconeElement->getFirstChild();
iter != 0; iter = iter->getNextSibling())
{
if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE) { continue; }
const xercesc::DOMElement* const child
= dynamic_cast<xercesc::DOMElement*>(iter);
if (!child)
{
G4Exception("G4GDMLReadSolids::GenericPolyconeRead()",
"InvalidRead", FatalException, "No child found!");
return;
}
const G4String tag = Transcode(child->getTagName());
if (tag=="rzpoint") { rzPointList.push_back(RZPointRead(child)); }
}
G4int numRZPoints = rzPointList.size();
G4double* r_array = new G4double[numRZPoints];
G4double* z_array = new G4double[numRZPoints];
for (G4int i=0; i<numRZPoints; i++)
{
r_array[i] = rzPointList[i].r*lunit;
z_array[i] = rzPointList[i].z*lunit;
}
new G4GenericPolycone(name,startphi,deltaphi,numRZPoints,
r_array,z_array);
}
void G4GDMLReadSolids::
PolyhedraRead(const xercesc::DOMElement* const polyhedraElement)
{
@@ -837,6 +920,87 @@ PolyhedraRead(const xercesc::DOMElement* const polyhedraElement)
}
void G4GDMLReadSolids::
GenericPolyhedraRead(const xercesc::DOMElement* const polyhedraElement)
{
G4String name;
G4double lunit = 1.0;
G4double aunit = 1.0;
G4double startphi = 0.0;
G4double deltaphi = 0.0;
G4int numsides = 0;
const xercesc::DOMNamedNodeMap* const attributes
= polyhedraElement->getAttributes();
XMLSize_t attributeCount = attributes->getLength();
for (XMLSize_t attribute_index=0;
attribute_index<attributeCount; attribute_index++)
{
xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
{ continue; }
const xercesc::DOMAttr* const attribute
= dynamic_cast<xercesc::DOMAttr*>(attribute_node);
if (!attribute)
{
G4Exception("G4GDMLReadSolids::GenericPolyhedraRead()",
"InvalidRead", FatalException, "No attribute found!");
return;
}
const G4String attName = Transcode(attribute->getName());
const G4String attValue = Transcode(attribute->getValue());
if (attName=="name") { name = GenerateName(attValue); } else
if (attName=="lunit") { lunit = eval.Evaluate(attValue); } else
if (attName=="aunit") { aunit = eval.Evaluate(attValue); } else
if (attName=="startphi") { startphi = eval.Evaluate(attValue); } else
if (attName=="deltaphi") { deltaphi = eval.Evaluate(attValue); } else
if (attName=="numsides") { numsides = eval.EvaluateInteger(attValue); }
}
startphi *= aunit;
deltaphi *= aunit;
std::vector<rzPointType> rzpointList;
for (xercesc::DOMNode* iter = polyhedraElement->getFirstChild();
iter != 0; iter = iter->getNextSibling())
{
if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE) { continue; }
const xercesc::DOMElement* const child
= dynamic_cast<xercesc::DOMElement*>(iter);
if (!child)
{
G4Exception("G4GDMLReadSolids::GenericPolyhedraRead()",
"InvalidRead", FatalException, "No child found!");
return;
}
const G4String tag = Transcode(child->getTagName());
if (tag=="rzpoint") { rzpointList.push_back(RZPointRead(child)); }
}
G4int numRZPoints = rzpointList.size();
G4double* r_array = new G4double[numRZPoints];
G4double* z_array = new G4double[numRZPoints];
for (G4int i=0; i<numRZPoints; i++)
{
r_array[i] = rzpointList[i].r*lunit;
z_array[i] = rzpointList[i].z*lunit;
}
new G4Polyhedra(name,startphi,deltaphi,numsides,numRZPoints,
r_array,z_array);
}
G4QuadrangularFacet* G4GDMLReadSolids::
QuadrangularRead(const xercesc::DOMElement* const quadrangularElement)
{
@@ -1858,6 +2022,40 @@ ZplaneRead(const xercesc::DOMElement* const zplaneElement)
return zplane;
}
G4GDMLReadSolids::rzPointType G4GDMLReadSolids::
RZPointRead(const xercesc::DOMElement* const zplaneElement)
{
rzPointType rzpoint = {0.,0.};
const xercesc::DOMNamedNodeMap* const attributes
= zplaneElement->getAttributes();
XMLSize_t attributeCount = attributes->getLength();
for (XMLSize_t attribute_index=0;
attribute_index<attributeCount; attribute_index++)
{
xercesc::DOMNode* node = attributes->item(attribute_index);
if (node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE) { continue; }
const xercesc::DOMAttr* const attribute
= dynamic_cast<xercesc::DOMAttr*>(node);
if (!attribute)
{
G4Exception("G4GDMLReadSolids::RZPointRead()",
"InvalidRead", FatalException, "No attribute found!");
return rzpoint;
}
const G4String attName = Transcode(attribute->getName());
const G4String attValue = Transcode(attribute->getValue());
if (attName=="r") { rzpoint.r = eval.Evaluate(attValue); } else
if (attName=="z") { rzpoint.z = eval.Evaluate(attValue); }
}
return rzpoint;
}
void G4GDMLReadSolids::
OpticalSurfaceRead(const xercesc::DOMElement* const opticalsurfaceElement)
@@ -2006,11 +2204,14 @@ void G4GDMLReadSolids::SolidsRead(const xercesc::DOMElement* const solidsElement
if (tag=="xtru") { XtruRead(child); } else
if (tag=="hype") { HypeRead(child); } else
if (tag=="intersection") { BooleanRead(child,INTERSECTION); } else
if (tag=="multiunion") { MultiUnionRead(child); } else
if (tag=="orb") { OrbRead(child); } else
if (tag=="para") { ParaRead(child); } else
if (tag=="paraboloid") { ParaboloidRead(child); } else
if (tag=="polycone") { PolyconeRead(child); } else
if (tag=="genericPolycone") { GenericPolyconeRead(child); } else
if (tag=="polyhedra") { PolyhedraRead(child); } else
if (tag=="genericPolyhedra") { GenericPolyhedraRead(child); } else
if (tag=="reflectedSolid") { ReflectedSolidRead(child); } else
if (tag=="sphere") { SphereRead(child); } else
if (tag=="subtraction") { BooleanRead(child,SUBTRACTION); } else
source/persistency/gdml/src/G4GDMLReadStructure.cc
+1 -1
View File
@@ -23,7 +23,7 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id$
// $Id: G4GDMLReadStructure.cc 68053 2013-03-13 14:39:51Z gcosmo $
//
// class G4GDMLReadStructure Implementation
//
source/persistency/gdml/src/G4GDMLWrite.cc
+1 -1
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id$
// $Id: G4GDMLWrite.cc 69013 2013-04-15 09:41:13Z gcosmo $
//
// class G4GDMLWrite Implementation
//
source/persistency/gdml/src/G4GDMLWriteDefine.cc
+1 -1
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id$
// $Id: G4GDMLWriteDefine.cc 68053 2013-03-13 14:39:51Z gcosmo $
//
// class G4GDMLWriteDefine Implementation
//
source/persistency/gdml/src/G4GDMLWriteMaterials.cc
+2 -2
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id$
// $Id: G4GDMLWriteMaterials.cc 70764 2013-06-05 12:54:37Z gcosmo $
//
// class G4GDMLWriteMaterials Implementation
//
@@ -74,7 +74,7 @@ PWrite(xercesc::DOMElement* element,const G4double& P)
{
xercesc::DOMElement* PElement = NewElement("P");
PElement->setAttributeNode(NewAttribute("unit","pascal"));
PElement->setAttributeNode(NewAttribute("value",P/pascal));
PElement->setAttributeNode(NewAttribute("value",P/hep_pascal));
element->appendChild(PElement);
}
source/persistency/gdml/src/G4GDMLWriteParamvol.cc
+106 -2
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id$
// $Id: G4GDMLWriteParamvol.cc 77913 2013-11-29 10:59:07Z gcosmo $
//
// class G4GDMLParamVol Implementation
//
@@ -33,6 +33,7 @@
// --------------------------------------------------------------------
#include "G4GDMLWriteParamvol.hh"
#include "G4GDMLWriteSolids.hh"
#include "G4SystemOfUnits.hh"
#include "G4Box.hh"
@@ -43,8 +44,11 @@
#include "G4Sphere.hh"
#include "G4Orb.hh"
#include "G4Torus.hh"
#include "G4Ellipsoid.hh"
#include "G4Para.hh"
#include "G4Hype.hh"
#include "G4Polycone.hh"
#include "G4Polyhedra.hh"
#include "G4LogicalVolume.hh"
#include "G4VPhysicalVolume.hh"
#include "G4PVParameterised.hh"
@@ -193,7 +197,7 @@ Sphere_dimensionsWrite(xercesc::DOMElement* parametersElement,
xercesc::DOMElement* sphere_dimensionsElement =
NewElement("sphere_dimensions");
sphere_dimensionsElement->setAttributeNode(NewAttribute("rmin",
sphere->GetInsideRadius()/mm));
sphere->GetInnerRadius()/mm));
sphere_dimensionsElement->setAttributeNode(NewAttribute("rmax",
sphere->GetOuterRadius()/mm));
sphere_dimensionsElement->setAttributeNode(NewAttribute("startphi",
@@ -243,11 +247,33 @@ Torus_dimensionsWrite(xercesc::DOMElement* parametersElement,
parametersElement->appendChild(torus_dimensionsElement);
}
void G4GDMLWriteParamvol::
Ellipsoid_dimensionsWrite(xercesc::DOMElement* parametersElement,
const G4Ellipsoid* const ellipsoid)
{
xercesc::DOMElement* ellipsoid_dimensionsElement =
NewElement("ellipsoid_dimensions");
ellipsoid_dimensionsElement->
setAttributeNode(NewAttribute("ax",ellipsoid->GetSemiAxisMax(0)/mm));
ellipsoid_dimensionsElement->
setAttributeNode(NewAttribute("by",ellipsoid->GetSemiAxisMax(1)/mm));
ellipsoid_dimensionsElement->
setAttributeNode(NewAttribute("cz",ellipsoid->GetSemiAxisMax(2)/mm));
ellipsoid_dimensionsElement->
setAttributeNode(NewAttribute("zcut1",ellipsoid->GetZBottomCut()/mm));
ellipsoid_dimensionsElement->
setAttributeNode(NewAttribute("zcut2",ellipsoid->GetZTopCut()/mm));
ellipsoid_dimensionsElement->
setAttributeNode(NewAttribute("lunit","mm"));
parametersElement->appendChild(ellipsoid_dimensionsElement);
}
void G4GDMLWriteParamvol::
Para_dimensionsWrite(xercesc::DOMElement* parametersElement,
const G4Para* const para)
{
const G4ThreeVector simaxis = para->GetSymAxis();
const G4double alpha = std::atan(para->GetTanAlpha());
const G4double theta = std::acos(simaxis.z());
const G4double phi = (simaxis.z() != 1.0)
@@ -295,6 +321,66 @@ Hype_dimensionsWrite(xercesc::DOMElement* parametersElement,
parametersElement->appendChild(hype_dimensionsElement);
}
void G4GDMLWriteParamvol::
Polycone_dimensionsWrite(xercesc::DOMElement* parametersElement,
const G4Polycone* const pcone)
{
xercesc::DOMElement* pcone_dimensionsElement
= NewElement("polycone_dimensions");
pcone_dimensionsElement->setAttributeNode(NewAttribute("numRZ",
pcone->GetOriginalParameters()->Num_z_planes));
pcone_dimensionsElement->setAttributeNode(NewAttribute("startPhi",
pcone->GetOriginalParameters()->Start_angle/degree));
pcone_dimensionsElement->setAttributeNode(NewAttribute("openPhi",
pcone->GetOriginalParameters()->Opening_angle/degree));
pcone_dimensionsElement->setAttributeNode(NewAttribute("aunit","deg"));
pcone_dimensionsElement->setAttributeNode(NewAttribute("lunit","mm"));
parametersElement->appendChild(pcone_dimensionsElement);
const size_t num_zplanes = pcone->GetOriginalParameters()->Num_z_planes;
const G4double* z_array = pcone->GetOriginalParameters()->Z_values;
const G4double* rmin_array = pcone->GetOriginalParameters()->Rmin;
const G4double* rmax_array = pcone->GetOriginalParameters()->Rmax;
for (size_t i=0; i<num_zplanes; i++)
{
ZplaneWrite(pcone_dimensionsElement,z_array[i],
rmin_array[i],rmax_array[i]);
}
}
void G4GDMLWriteParamvol::
Polyhedra_dimensionsWrite(xercesc::DOMElement* parametersElement,
const G4Polyhedra* const polyhedra)
{
xercesc::DOMElement* polyhedra_dimensionsElement
= NewElement("polyhedra_dimensions");
polyhedra_dimensionsElement->setAttributeNode(NewAttribute("numRZ",
polyhedra->GetOriginalParameters()->Num_z_planes));
polyhedra_dimensionsElement->setAttributeNode(NewAttribute("numSide",
polyhedra->GetOriginalParameters()->numSide));
polyhedra_dimensionsElement->setAttributeNode(NewAttribute("startPhi",
polyhedra->GetOriginalParameters()->Start_angle/degree));
polyhedra_dimensionsElement->setAttributeNode(NewAttribute("openPhi",
polyhedra->GetOriginalParameters()->Opening_angle/degree));
polyhedra_dimensionsElement->setAttributeNode(NewAttribute("aunit","deg"));
polyhedra_dimensionsElement->setAttributeNode(NewAttribute("lunit","mm"));
parametersElement->appendChild(polyhedra_dimensionsElement);
const size_t num_zplanes = polyhedra->GetOriginalParameters()->Num_z_planes;
const G4double* z_array = polyhedra->GetOriginalParameters()->Z_values;
const G4double* rmin_array = polyhedra->GetOriginalParameters()->Rmin;
const G4double* rmax_array = polyhedra->GetOriginalParameters()->Rmax;
for (size_t i=0; i<num_zplanes; i++)
{
ZplaneWrite(polyhedra_dimensionsElement,z_array[i],
rmin_array[i],rmax_array[i]);
}
}
void G4GDMLWriteParamvol::
ParametersWrite(xercesc::DOMElement* paramvolElement,
const G4VPhysicalVolume* const paramvol,const G4int& index)
@@ -371,6 +457,12 @@ ParametersWrite(xercesc::DOMElement* paramvolElement,
const_cast<G4VPhysicalVolume*>(paramvol));
Torus_dimensionsWrite(parametersElement,torus);
} else
if (G4Ellipsoid* ellipsoid = dynamic_cast<G4Ellipsoid*>(solid))
{
paramvol->GetParameterisation()->ComputeDimensions(*ellipsoid,index,
const_cast<G4VPhysicalVolume*>(paramvol));
Ellipsoid_dimensionsWrite(parametersElement,ellipsoid);
} else
if (G4Para* para = dynamic_cast<G4Para*>(solid))
{
paramvol->GetParameterisation()->ComputeDimensions(*para,index,
@@ -382,6 +474,18 @@ ParametersWrite(xercesc::DOMElement* paramvolElement,
paramvol->GetParameterisation()->ComputeDimensions(*hype,index,
const_cast<G4VPhysicalVolume*>(paramvol));
Hype_dimensionsWrite(parametersElement,hype);
}else
if (G4Polycone* pcone = dynamic_cast<G4Polycone*>(solid))
{
paramvol->GetParameterisation()->ComputeDimensions(*pcone,index,
const_cast<G4VPhysicalVolume*>(paramvol));
Polycone_dimensionsWrite(parametersElement,pcone);
}else
if (G4Polyhedra* polyhedra = dynamic_cast<G4Polyhedra*>(solid))
{
paramvol->GetParameterisation()->ComputeDimensions(*polyhedra,index,
const_cast<G4VPhysicalVolume*>(paramvol));
Polyhedra_dimensionsWrite(parametersElement,polyhedra);
}
else
{
source/persistency/gdml/src/G4GDMLWriteSetup.cc
+1 -1
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id$
// $Id: G4GDMLWriteSetup.cc 68053 2013-03-13 14:39:51Z gcosmo $
//
// class G4GDMLWriteSetup Implementation
//
source/persistency/gdml/src/G4GDMLWriteSolids.cc
+99 -35
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id$
// $Id: G4GDMLWriteSolids.cc 76271 2013-11-08 11:51:39Z gcosmo $
//
// class G4GDMLWriteSolids Implementation
//
@@ -48,6 +48,7 @@
#include "G4Paraboloid.hh"
#include "G4IntersectionSolid.hh"
#include "G4Polycone.hh"
#include "G4GenericPolycone.hh"
#include "G4Polyhedra.hh"
#include "G4ReflectedSolid.hh"
#include "G4Sphere.hh"
@@ -409,32 +410,59 @@ ParaboloidWrite(xercesc::DOMElement* solElement,
paraboloidElement->setAttributeNode(NewAttribute("lunit","mm"));
solElement->appendChild(paraboloidElement);
}
void G4GDMLWriteSolids::
PolyconeWrite(xercesc::DOMElement* solElement,
const G4Polycone* const polycone)
{
const G4String& name = GenerateName(polycone->GetName(),polycone);
xercesc::DOMElement* polyconeElement = NewElement("polycone");
polyconeElement->setAttributeNode(NewAttribute("name",name));
polyconeElement->setAttributeNode(NewAttribute("startphi",
xercesc::DOMElement* polyconeElement = NewElement("polycone");
polyconeElement->setAttributeNode(NewAttribute("name",name));
polyconeElement->setAttributeNode(NewAttribute("startphi",
polycone->GetOriginalParameters()->Start_angle/degree));
polyconeElement->setAttributeNode(NewAttribute("deltaphi",
polyconeElement->setAttributeNode(NewAttribute("deltaphi",
polycone->GetOriginalParameters()->Opening_angle/degree));
polyconeElement->setAttributeNode(NewAttribute("aunit","deg"));
polyconeElement->setAttributeNode(NewAttribute("lunit","mm"));
solElement->appendChild(polyconeElement);
polyconeElement->setAttributeNode(NewAttribute("aunit","deg"));
polyconeElement->setAttributeNode(NewAttribute("lunit","mm"));
solElement->appendChild(polyconeElement);
const size_t num_zplanes = polycone->GetOriginalParameters()->Num_z_planes;
const G4double* z_array = polycone->GetOriginalParameters()->Z_values;
const G4double* rmin_array = polycone->GetOriginalParameters()->Rmin;
const G4double* rmax_array = polycone->GetOriginalParameters()->Rmax;
const size_t num_zplanes = polycone->GetOriginalParameters()->Num_z_planes;
const G4double* z_array = polycone->GetOriginalParameters()->Z_values;
const G4double* rmin_array = polycone->GetOriginalParameters()->Rmin;
const G4double* rmax_array = polycone->GetOriginalParameters()->Rmax;
for (size_t i=0; i<num_zplanes; i++)
{
for (size_t i=0; i<num_zplanes; i++)
{
ZplaneWrite(polyconeElement,z_array[i],rmin_array[i],rmax_array[i]);
}
}
}
void G4GDMLWriteSolids::
GenericPolyconeWrite(xercesc::DOMElement* solElement,
const G4GenericPolycone* const polycone)
{
const G4String& name = GenerateName(polycone->GetName(),polycone);
xercesc::DOMElement* polyconeElement = NewElement("genericPolycone");
const G4double startPhi=polycone->GetStartPhi();
polyconeElement->setAttributeNode(NewAttribute("name",name));
polyconeElement->setAttributeNode(NewAttribute("startphi",
startPhi/degree));
polyconeElement->setAttributeNode(NewAttribute("deltaphi",
(polycone->GetEndPhi()-startPhi)/degree));
polyconeElement->setAttributeNode(NewAttribute("aunit","deg"));
polyconeElement->setAttributeNode(NewAttribute("lunit","mm"));
solElement->appendChild(polyconeElement);
const size_t num_rzpoints = polycone->GetNumRZCorner();
for (size_t i=0; i<num_rzpoints; i++)
{
const G4double r_point=polycone->GetCorner(i).r;
const G4double z_point=polycone->GetCorner(i).z;
RZPointWrite(polyconeElement,r_point,z_point);
}
}
void G4GDMLWriteSolids::
@@ -442,33 +470,56 @@ PolyhedraWrite(xercesc::DOMElement* solElement,
const G4Polyhedra* const polyhedra)
{
const G4String& name = GenerateName(polyhedra->GetName(),polyhedra);
xercesc::DOMElement* polyhedraElement = NewElement("polyhedra");
polyhedraElement->setAttributeNode(NewAttribute("name",name));
polyhedraElement->setAttributeNode(NewAttribute("startphi",
if(polyhedra->IsGeneric() == false){
xercesc::DOMElement* polyhedraElement = NewElement("polyhedra");
polyhedraElement->setAttributeNode(NewAttribute("name",name));
polyhedraElement->setAttributeNode(NewAttribute("startphi",
polyhedra->GetOriginalParameters()->Start_angle/degree));
polyhedraElement->setAttributeNode(NewAttribute("deltaphi",
polyhedraElement->setAttributeNode(NewAttribute("deltaphi",
polyhedra->GetOriginalParameters()->Opening_angle/degree));
polyhedraElement->setAttributeNode(NewAttribute("numsides",
polyhedraElement->setAttributeNode(NewAttribute("numsides",
polyhedra->GetOriginalParameters()->numSide));
polyhedraElement->setAttributeNode(NewAttribute("aunit","deg"));
polyhedraElement->setAttributeNode(NewAttribute("lunit","mm"));
solElement->appendChild(polyhedraElement);
polyhedraElement->setAttributeNode(NewAttribute("aunit","deg"));
polyhedraElement->setAttributeNode(NewAttribute("lunit","mm"));
solElement->appendChild(polyhedraElement);
const size_t num_zplanes = polyhedra->GetOriginalParameters()->Num_z_planes;
const G4double* z_array = polyhedra->GetOriginalParameters()->Z_values;
const G4double* rmin_array = polyhedra->GetOriginalParameters()->Rmin;
const G4double* rmax_array = polyhedra->GetOriginalParameters()->Rmax;
const size_t num_zplanes = polyhedra->GetOriginalParameters()->Num_z_planes;
const G4double* z_array = polyhedra->GetOriginalParameters()->Z_values;
const G4double* rmin_array = polyhedra->GetOriginalParameters()->Rmin;
const G4double* rmax_array = polyhedra->GetOriginalParameters()->Rmax;
const G4double convertRad =
const G4double convertRad =
std::cos(0.5*polyhedra->GetOriginalParameters()->Opening_angle
/ polyhedra->GetOriginalParameters()->numSide);
for (size_t i=0;i<num_zplanes;i++)
{
for (size_t i=0;i<num_zplanes;i++)
{
ZplaneWrite(polyhedraElement,z_array[i],
rmin_array[i]*convertRad, rmax_array[i]*convertRad);
}
}
}else{//generic polyhedra
xercesc::DOMElement* polyhedraElement = NewElement("genericPolyhedra");
polyhedraElement->setAttributeNode(NewAttribute("name",name));
polyhedraElement->setAttributeNode(NewAttribute("startphi",
polyhedra->GetOriginalParameters()->Start_angle/degree));
polyhedraElement->setAttributeNode(NewAttribute("deltaphi",
polyhedra->GetOriginalParameters()->Opening_angle/degree));
polyhedraElement->setAttributeNode(NewAttribute("numsides",
polyhedra->GetOriginalParameters()->numSide));
polyhedraElement->setAttributeNode(NewAttribute("aunit","deg"));
polyhedraElement->setAttributeNode(NewAttribute("lunit","mm"));
solElement->appendChild(polyhedraElement);
const size_t num_rzpoints = polyhedra->GetNumRZCorner();
for (size_t i=0;i<num_rzpoints;i++)
{
const G4double r_point = polyhedra->GetCorner(i).r;
const G4double z_point = polyhedra->GetCorner(i).z;
RZPointWrite(polyhedraElement,r_point,z_point);
}
}
}
void G4GDMLWriteSolids::
@@ -479,7 +530,7 @@ SphereWrite(xercesc::DOMElement* solElement, const G4Sphere* const sphere)
xercesc::DOMElement* sphereElement = NewElement("sphere");
sphereElement->setAttributeNode(NewAttribute("name",name));
sphereElement->setAttributeNode(NewAttribute("rmin",
sphere->GetInsideRadius()/mm));
sphere->GetInnerRadius()/mm));
sphereElement->setAttributeNode(NewAttribute("rmax",
sphere->GetOuterRadius()/mm));
sphereElement->setAttributeNode(NewAttribute("startphi",
@@ -872,6 +923,16 @@ ZplaneWrite(xercesc::DOMElement* element, const G4double& z,
element->appendChild(zplaneElement);
}
void G4GDMLWriteSolids::
RZPointWrite(xercesc::DOMElement* element, const G4double& r,
const G4double& z)
{
xercesc::DOMElement* rzpointElement = NewElement("rzpoint");
rzpointElement->setAttributeNode(NewAttribute("r",r/mm));
rzpointElement->setAttributeNode(NewAttribute("z",z/mm));
element->appendChild(rzpointElement);
}
void G4GDMLWriteSolids::
OpticalSurfaceWrite(xercesc::DOMElement* solElement,
const G4OpticalSurface* const surf)
@@ -944,6 +1005,9 @@ void G4GDMLWriteSolids::AddSolid(const G4VSolid* const solidPtr)
if (const G4Polycone* const polyconePtr
= dynamic_cast<const G4Polycone*>(solidPtr))
{ PolyconeWrite(solidsElement,polyconePtr); } else
if (const G4GenericPolycone* const genpolyconePtr
= dynamic_cast<const G4GenericPolycone*>(solidPtr))
{ GenericPolyconeWrite(solidsElement,genpolyconePtr); } else
if (const G4Polyhedra* const polyhedraPtr
= dynamic_cast<const G4Polyhedra*>(solidPtr))
{ PolyhedraWrite(solidsElement,polyhedraPtr); } else
source/persistency/gdml/src/G4GDMLWriteStructure.cc
+1 -1
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id$
// $Id: G4GDMLWriteStructure.cc 68053 2013-03-13 14:39:51Z gcosmo $
//
// class G4GDMLWriteStructure Implementation
//
source/persistency/gdml/src/G4STRead.cc
+1 -1
View File
@@ -23,7 +23,7 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id$
// $Id: G4STRead.cc 68053 2013-03-13 14:39:51Z gcosmo $
//
// class G4STRead Implementation
//