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

Import Geant4 10.1.0 source tree

Browse Source
This commit is contained in:
Gabriele Cosmo
2016-06-10 12:08:39 +02:00
parent 286caacf06
commit c9b32a6c0a
5770 changed files with 1050949 additions and 367105 deletions
Download Patch File Download Diff File Expand all files Collapse all files
source/persistency/gdml/src/G4GDMLMessenger.cc
+2 -5
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id: G4GDMLMessenger.cc 68053 2013-03-13 14:39:51Z gcosmo $
// $Id: G4GDMLMessenger.cc 86446 2014-11-12 09:45:58Z gcosmo $
//
//
// class G4GDMLMessenger Implementation
@@ -104,9 +104,6 @@ void G4GDMLMessenger::SetNewValue(G4UIcommand* command, G4String newValue)
if( command == ClearCmd )
{
myParser->Clear();
G4GeometryManager::GetInstance()->OpenGeometry();
G4PhysicalVolumeStore::Clean();
G4LogicalVolumeStore::Clean();
G4SolidStore::Clean();
G4RunManager::GetRunManager()->ReinitializeGeometry(true);
}
}
source/persistency/gdml/src/G4GDMLParser.cc
+3 -3
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id: G4GDMLParser.cc 68053 2013-03-13 14:39:51Z gcosmo $
// $Id: G4GDMLParser.cc 80934 2014-05-16 14:06:39Z gcosmo $
//
//
// class G4GDMLParser Implementation
@@ -44,7 +44,7 @@ G4GDMLParser::G4GDMLParser()
}
G4GDMLParser::G4GDMLParser(G4GDMLReadStructure* extr)
: urcode(true), uwcode(false)
: urcode(true), uwcode(false), strip(true)
{
reader = extr;
writer = new G4GDMLWriteStructure;
@@ -55,7 +55,7 @@ G4GDMLParser::G4GDMLParser(G4GDMLReadStructure* extr)
G4GDMLParser::G4GDMLParser(G4GDMLReadStructure* extr,
G4GDMLWriteStructure* extw)
: urcode(true), uwcode(true)
: urcode(true), uwcode(true), strip(true)
{
reader = extr;
writer = extw;
source/persistency/gdml/src/G4GDMLRead.cc
+16 -7
View File
@@ -23,7 +23,7 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4GDMLRead.cc 68053 2013-03-13 14:39:51Z gcosmo $
// $Id: G4GDMLRead.cc 81112 2014-05-21 08:50:44Z gcosmo $
//
// class G4GDMLRead Implementation
//
@@ -123,7 +123,7 @@ void G4GDMLRead::StripNames() const
<< G4endl;
G4String sname;
register size_t i;
size_t i;
// Solids...
//
@@ -288,13 +288,16 @@ void G4GDMLRead::Read(const G4String& fileName,
xercesc::ErrorHandler* handler = new G4GDMLErrorHandler(!validate);
xercesc::XercesDOMParser* parser = new xercesc::XercesDOMParser;
parser->setValidationScheme(xercesc::XercesDOMParser::Val_Always);
parser->setValidationSchemaFullChecking(true);
if (validate)
{
parser->setValidationScheme(xercesc::XercesDOMParser::Val_Always);
}
parser->setValidationSchemaFullChecking(validate);
parser->setCreateEntityReferenceNodes(false);
// Entities will be automatically resolved by Xerces
parser->setDoNamespaces(true);
parser->setDoSchema(true);
parser->setDoSchema(validate);
parser->setErrorHandler(handler);
try { parser->parse(fileName.c_str()); }
@@ -316,8 +319,14 @@ void G4GDMLRead::Read(const G4String& fileName,
if (!element)
{
G4Exception("G4GDMLRead::Read()", "InvalidRead",
FatalException, "Empty document!");
std::ostringstream message;
message << "ERROR - Empty document!" << G4endl
<< " Check Internet connection is ON in case of schema"
<< G4endl
<< " validation enabled and location defined as URL in"
<< G4endl
<< " the GDML file - " << fileName << " - being imported!";
G4Exception("G4GDMLRead::Read()", "InvalidRead", FatalException, message);
return;
}
source/persistency/gdml/src/G4GDMLReadMaterials.cc
+3 -3
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id: G4GDMLReadMaterials.cc 70764 2013-06-05 12:54:37Z gcosmo $
// $Id: G4GDMLReadMaterials.cc 86379 2014-11-10 11:34:33Z gcosmo $
// GEANT4 tag $ Name:$
//
// class G4GDMLReadMaterials Implementation
@@ -581,8 +581,8 @@ MixtureRead(const xercesc::DOMElement *const mixtureElement,
G4Material *materialPtr = GetMaterial(GenerateName(ref,true), false);
G4Element *elementPtr = GetElement(GenerateName(ref,true), false);
if (materialPtr != 0) { material->AddMaterial(materialPtr,n); } else
if (elementPtr != 0) { material->AddElement(elementPtr,n); }
if (elementPtr != 0) { material->AddElement(elementPtr,n); } else
if (materialPtr != 0) { material->AddMaterial(materialPtr,n); }
if ((materialPtr == 0) && (elementPtr == 0))
{
source/persistency/gdml/src/G4GDMLReadSolids.cc
+150 -7
View File
@@ -23,7 +23,7 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4GDMLReadSolids.cc 77528 2013-11-25 13:06:36Z gcosmo $
// $Id: G4GDMLReadSolids.cc 86814 2014-11-18 14:47:24Z gcosmo $
//
// class G4GDMLReadSolids Implementation
//
@@ -535,11 +535,144 @@ void G4GDMLReadSolids::HypeRead(const xercesc::DOMElement* const hypeElement)
new G4Hype(name,rmin,rmax,inst,outst,z);
}
void G4GDMLReadSolids::MultiUnionRead(const xercesc::DOMElement* const)
void G4GDMLReadSolids::
MultiUnionNodeRead(const xercesc::DOMElement* const unionNodeElement,
G4MultiUnion* const multiUnionSolid)
{
#if !defined(G4GEOM_USE_USOLIDS)
G4Exception("G4GDMLReadSolids::MultiUnionNodeRead()",
"InvalidSetup", FatalException,
"Installation with USolids primitives required!");
return;
#endif
G4String name;
G4String solid;
G4ThreeVector position(0.0,0.0,0.0);
G4ThreeVector rotation(0.0,0.0,0.0);
const xercesc::DOMNamedNodeMap* const attributes
= unionNodeElement->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::MultiUnionNodeRead()",
"InvalidRead", FatalException, "No attribute found!");
return;
}
const G4String attName = Transcode(attribute->getName());
const G4String attValue = Transcode(attribute->getValue());
if (attName=="name") { name = GenerateName(attValue); }
}
for (xercesc::DOMNode* iter = unionNodeElement->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::MultiUnionNodeRead()",
"InvalidRead", FatalException, "No child found!");
return;
}
const G4String tag = Transcode(child->getTagName());
if (tag=="position") { VectorRead(child,position); } else
if (tag=="rotation") { VectorRead(child,rotation); } else
if (tag=="positionref")
{ position = GetPosition(GenerateName(RefRead(child))); } else
if (tag=="rotationref")
{ rotation = GetRotation(GenerateName(RefRead(child))); } else
if (tag=="solid") { solid = RefRead(child); }
else
{
G4String error_msg = "Unknown tag in MultiUnion structure: " + tag;
G4Exception("G4GDMLReadSolids::MultiUnionNodeRead()", "ReadError",
FatalException, error_msg);
}
}
G4VSolid* solidNode = GetSolid(GenerateName(solid));
G4Transform3D transform(GetRotationMatrix(rotation),position);
multiUnionSolid->AddNode(*solidNode, transform);
}
void G4GDMLReadSolids::
MultiUnionRead(const xercesc::DOMElement* const unionElement)
{
#if !defined(G4GEOM_USE_USOLIDS)
G4Exception("G4GDMLReadSolids::MultiUnionRead()",
"InvalidSetup", JustWarning,
"MultiUnion is not supported yet. Sorry!");
"InvalidSetup", FatalException,
"Installation with USolids primitives required!");
return;
#endif
G4String name;
const xercesc::DOMNamedNodeMap* const attributes
= unionElement->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::MultiUnionRead()",
"InvalidRead", FatalException, "No attribute found!");
return;
}
const G4String attName = Transcode(attribute->getName());
const G4String attValue = Transcode(attribute->getValue());
if (attName=="name") { name = GenerateName(attValue); }
}
G4MultiUnion* multiUnion = new G4MultiUnion(name);
for (xercesc::DOMNode* iter = unionElement->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::MultiUnionRead()",
"InvalidRead", FatalException, "No child found!");
return;
}
const G4String tag = Transcode(child->getTagName());
if (tag=="multiUnionNode") { MultiUnionNodeRead(child, multiUnion); }
else
{
G4String error_msg = "Unknown tag in MultiUnion structure: " + tag;
G4Exception("G4GDMLReadSolids::MultiUnionRead()", "ReadError",
FatalException, error_msg);
}
}
multiUnion->Voxelize();
}
void G4GDMLReadSolids::OrbRead(const xercesc::DOMElement* const orbElement)
@@ -760,6 +893,10 @@ PolyconeRead(const xercesc::DOMElement* const polyconeElement)
new G4Polycone(name,startphi,deltaphi,numZPlanes,
z_array,rmin_array,rmax_array);
delete [] rmin_array;
delete [] rmax_array;
delete [] z_array;
}
void G4GDMLReadSolids::
@@ -827,7 +964,7 @@ GenericPolyconeRead(const xercesc::DOMElement* const polyconeElement)
G4int numRZPoints = rzPointList.size();
G4double* r_array = new G4double[numRZPoints];
G4double* z_array = new G4double[numRZPoints];
G4double* z_array = new G4double[numRZPoints];
for (G4int i=0; i<numRZPoints; i++)
{
@@ -836,6 +973,8 @@ GenericPolyconeRead(const xercesc::DOMElement* const polyconeElement)
}
new G4GenericPolycone(name,startphi,deltaphi,numRZPoints,
r_array,z_array);
delete [] r_array;
delete [] z_array;
}
void G4GDMLReadSolids::
@@ -918,6 +1057,9 @@ PolyhedraRead(const xercesc::DOMElement* const polyhedraElement)
new G4Polyhedra(name,startphi,deltaphi,numsides,numZPlanes,
z_array,rmin_array,rmax_array);
delete [] rmin_array;
delete [] rmax_array;
delete [] z_array;
}
void G4GDMLReadSolids::
@@ -988,7 +1130,6 @@ GenericPolyhedraRead(const xercesc::DOMElement* const polyhedraElement)
G4double* r_array = new G4double[numRZPoints];
G4double* z_array = new G4double[numRZPoints];
for (G4int i=0; i<numRZPoints; i++)
{
@@ -999,6 +1140,8 @@ GenericPolyhedraRead(const xercesc::DOMElement* const polyhedraElement)
new G4Polyhedra(name,startphi,deltaphi,numsides,numRZPoints,
r_array,z_array);
delete [] r_array;
delete [] z_array;
}
G4QuadrangularFacet* G4GDMLReadSolids::
@@ -2204,7 +2347,7 @@ 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=="multiUnion") { MultiUnionRead(child); } else
if (tag=="orb") { OrbRead(child); } else
if (tag=="para") { ParaRead(child); } else
if (tag=="paraboloid") { ParaboloidRead(child); } else
source/persistency/gdml/src/G4GDMLWriteSolids.cc
+174 -87
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id: G4GDMLWriteSolids.cc 76271 2013-11-08 11:51:39Z gcosmo $
// $Id: G4GDMLWriteSolids.cc 87077 2014-11-24 15:29:00Z gcosmo $
//
// class G4GDMLWriteSolids Implementation
//
@@ -78,6 +78,65 @@ G4GDMLWriteSolids::~G4GDMLWriteSolids()
{
}
void G4GDMLWriteSolids::
MultiUnionWrite(xercesc::DOMElement* solElement,
const G4MultiUnion* const munionSolid)
{
G4int numSolids=munionSolid->GetNumberOfSolids();
G4String tag("multiUnion");
G4VSolid* solid;
G4Transform3D* transform;
const G4String& name = GenerateName(munionSolid->GetName(),munionSolid);
xercesc::DOMElement* multiUnionElement = NewElement(tag);
multiUnionElement->setAttributeNode(NewAttribute("name",name));
for (G4int i=0; i<numSolids; ++i)
{
solid = munionSolid->GetSolid(i);
transform = munionSolid->GetTransformation(i);
HepGeom::Rotate3D rot3d;
HepGeom::Translate3D transl ;
HepGeom::Scale3D scale;
transform->getDecomposition(scale,rot3d,transl);
G4ThreeVector pos = transl.getTranslation();
G4RotationMatrix
rotm(CLHEP::HepRep3x3(rot3d.xx(), rot3d.xy(), rot3d.xz(),
rot3d.yx(), rot3d.yy(), rot3d.yz(),
rot3d.zx(), rot3d.zy(), rot3d.zz()));
G4ThreeVector rot = GetAngles(rotm);
AddSolid(solid);
const G4String& solidref = GenerateName(solid->GetName(),solid);
std::ostringstream os; os << i+1;
const G4String& nodeName = "Node-" + G4String(os.str());
xercesc::DOMElement* solidElement = NewElement("solid");
solidElement->setAttributeNode(NewAttribute("ref",solidref));
xercesc::DOMElement* multiUnionNodeElement = NewElement("multiUnionNode");
multiUnionNodeElement->setAttributeNode(NewAttribute("name", nodeName));
multiUnionNodeElement->appendChild(solidElement); // Append solid to node
if ( (std::fabs(pos.x()) > kLinearPrecision)
|| (std::fabs(pos.y()) > kLinearPrecision)
|| (std::fabs(pos.z()) > kLinearPrecision) )
{
PositionWrite(multiUnionNodeElement,name+"_pos",pos);
}
if ( (std::fabs(rot.x()) > kAngularPrecision)
|| (std::fabs(rot.y()) > kAngularPrecision)
|| (std::fabs(rot.z()) > kAngularPrecision) )
{
RotationWrite(multiUnionNodeElement,name+"_rot",rot);
}
multiUnionElement->appendChild(multiUnionNodeElement); // Append node
}
solElement->appendChild(multiUnionElement);
// Add the multiUnion solid AFTER the constituent nodes!
}
void G4GDMLWriteSolids::
BooleanWrite(xercesc::DOMElement* solElement,
const G4BooleanSolid* const boolean)
@@ -115,7 +174,7 @@ BooleanWrite(xercesc::DOMElement* solElement,
if (G4DisplacedSolid* disp = dynamic_cast<G4DisplacedSolid*>(firstPtr))
{
firstpos += disp->GetObjectTranslation();
firstrot += firstrot + GetAngles(disp->GetObjectRotation());
firstrot += GetAngles(disp->GetObjectRotation());
firstPtr = disp->GetConstituentMovedSolid();
displaced++;
continue;
@@ -373,9 +432,8 @@ ParaWrite(xercesc::DOMElement* solElement, 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)
? (std::atan(simaxis.y()/simaxis.x())) : (0.0);
const G4double phi = simaxis.phi();
const G4double theta = simaxis.theta();
xercesc::DOMElement* paraElement = NewElement("para");
paraElement->setAttributeNode(NewAttribute("name",name));
@@ -559,7 +617,7 @@ TessellatedWrite(xercesc::DOMElement* solElement,
tessellatedElement->setAttributeNode(NewAttribute("lunit","mm"));
solElement->appendChild(tessellatedElement);
std::map<G4ThreeVector, G4String> vertexMap;
std::map<G4ThreeVector, G4String, G4ThreeVectorCompare> vertexMap;
const size_t NumFacets = tessellated->GetNumberOfFacets();
size_t NumVertex = 0;
@@ -699,9 +757,8 @@ TrapWrite(xercesc::DOMElement* solElement, const G4Trap* const trap)
const G4String& name = GenerateName(trap->GetName(),trap);
const G4ThreeVector& simaxis = trap->GetSymAxis();
const G4double phi = (simaxis.z() != 1.0)
? (std::atan(simaxis.y()/simaxis.x())) : (0.0);
const G4double theta = std::acos(simaxis.z());
const G4double phi = simaxis.phi();
const G4double theta = simaxis.theta();
const G4double alpha1 = std::atan(trap->GetTanAlpha1());
const G4double alpha2 = std::atan(trap->GetTanAlpha2());
@@ -972,84 +1029,114 @@ void G4GDMLWriteSolids::AddSolid(const G4VSolid* const solidPtr)
if (const G4BooleanSolid* const booleanPtr
= dynamic_cast<const G4BooleanSolid*>(solidPtr))
{ BooleanWrite(solidsElement,booleanPtr); } else
if (const G4Box* const boxPtr
= dynamic_cast<const G4Box*>(solidPtr))
{ BoxWrite(solidsElement,boxPtr); } else
if (const G4Cons* const conePtr
= dynamic_cast<const G4Cons*>(solidPtr))
{ ConeWrite(solidsElement,conePtr); } else
if (const G4EllipticalCone* const elconePtr
= dynamic_cast<const G4EllipticalCone*>(solidPtr))
{ ElconeWrite(solidsElement,elconePtr); } else
if (const G4Ellipsoid* const ellipsoidPtr
= dynamic_cast<const G4Ellipsoid*>(solidPtr))
{ EllipsoidWrite(solidsElement,ellipsoidPtr); } else
if (const G4EllipticalTube* const eltubePtr
= dynamic_cast<const G4EllipticalTube*>(solidPtr))
{ EltubeWrite(solidsElement,eltubePtr); } else
if (const G4ExtrudedSolid* const xtruPtr
= dynamic_cast<const G4ExtrudedSolid*>(solidPtr))
{ XtruWrite(solidsElement,xtruPtr); } else
if (const G4Hype* const hypePtr
= dynamic_cast<const G4Hype*>(solidPtr))
{ HypeWrite(solidsElement,hypePtr); } else
if (const G4Orb* const orbPtr
= dynamic_cast<const G4Orb*>(solidPtr))
{ OrbWrite(solidsElement,orbPtr); } else
if (const G4Para* const paraPtr
= dynamic_cast<const G4Para*>(solidPtr))
{ ParaWrite(solidsElement,paraPtr); } else
if (const G4Paraboloid* const paraboloidPtr
= dynamic_cast<const G4Paraboloid*>(solidPtr))
{ ParaboloidWrite(solidsElement,paraboloidPtr); } else
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
if (const G4Sphere* const spherePtr
= dynamic_cast<const G4Sphere*>(solidPtr))
{ SphereWrite(solidsElement,spherePtr); } else
if (const G4TessellatedSolid* const tessellatedPtr
= dynamic_cast<const G4TessellatedSolid*>(solidPtr))
{ TessellatedWrite(solidsElement,tessellatedPtr); } else
if (const G4Tet* const tetPtr
= dynamic_cast<const G4Tet*>(solidPtr))
{ TetWrite(solidsElement,tetPtr); } else
if (const G4Torus* const torusPtr
= dynamic_cast<const G4Torus*>(solidPtr))
{ TorusWrite(solidsElement,torusPtr); } else
if (const G4GenericTrap* const gtrapPtr
= dynamic_cast<const G4GenericTrap*>(solidPtr))
{ GenTrapWrite(solidsElement,gtrapPtr); } else
if (const G4Trap* const trapPtr
= dynamic_cast<const G4Trap*>(solidPtr))
{ TrapWrite(solidsElement,trapPtr); } else
if (const G4Trd* const trdPtr
= dynamic_cast<const G4Trd*>(solidPtr))
{ TrdWrite(solidsElement,trdPtr); } else
if (const G4Tubs* const tubePtr
= dynamic_cast<const G4Tubs*>(solidPtr))
{ TubeWrite(solidsElement,tubePtr); } else
if (const G4CutTubs* const cuttubePtr
= dynamic_cast<const G4CutTubs*>(solidPtr))
{ CutTubeWrite(solidsElement,cuttubePtr); } else
if (const G4TwistedBox* const twistedboxPtr
= dynamic_cast<const G4TwistedBox*>(solidPtr))
{ TwistedboxWrite(solidsElement,twistedboxPtr); } else
if (const G4TwistedTrap* const twistedtrapPtr
= dynamic_cast<const G4TwistedTrap*>(solidPtr))
{ TwistedtrapWrite(solidsElement,twistedtrapPtr); } else
if (const G4TwistedTrd* const twistedtrdPtr
= dynamic_cast<const G4TwistedTrd*>(solidPtr))
{ TwistedtrdWrite(solidsElement,twistedtrdPtr); } else
if (const G4TwistedTubs* const twistedtubsPtr
= dynamic_cast<const G4TwistedTubs*>(solidPtr))
{ TwistedtubsWrite(solidsElement,twistedtubsPtr); }
if (solidPtr->GetEntityType()=="G4MultipleUnion")
{ const G4MultiUnion* const munionPtr
= static_cast<const G4MultiUnion*>(solidPtr);
MultiUnionWrite(solidsElement,munionPtr); } else
if (solidPtr->GetEntityType()=="G4Box")
{ const G4Box* const boxPtr
= static_cast<const G4Box*>(solidPtr);
BoxWrite(solidsElement,boxPtr); } else
if (solidPtr->GetEntityType()=="G4Cons")
{ const G4Cons* const conePtr
= static_cast<const G4Cons*>(solidPtr);
ConeWrite(solidsElement,conePtr); } else
if (solidPtr->GetEntityType()=="G4EllipticalCone")
{ const G4EllipticalCone* const elconePtr
= static_cast<const G4EllipticalCone*>(solidPtr);
ElconeWrite(solidsElement,elconePtr); } else
if (solidPtr->GetEntityType()=="G4Ellipsoid")
{ const G4Ellipsoid* const ellipsoidPtr
= static_cast<const G4Ellipsoid*>(solidPtr);
EllipsoidWrite(solidsElement,ellipsoidPtr); } else
if (solidPtr->GetEntityType()=="G4EllipticalTube")
{ const G4EllipticalTube* const eltubePtr
= static_cast<const G4EllipticalTube*>(solidPtr);
EltubeWrite(solidsElement,eltubePtr); } else
if (solidPtr->GetEntityType()=="G4ExtrudedSolid")
{ const G4ExtrudedSolid* const xtruPtr
= static_cast<const G4ExtrudedSolid*>(solidPtr);
XtruWrite(solidsElement,xtruPtr); } else
if (solidPtr->GetEntityType()=="G4Hype")
{ const G4Hype* const hypePtr
= static_cast<const G4Hype*>(solidPtr);
HypeWrite(solidsElement,hypePtr); } else
if (solidPtr->GetEntityType()=="G4Orb")
{ const G4Orb* const orbPtr
= static_cast<const G4Orb*>(solidPtr);
OrbWrite(solidsElement,orbPtr); } else
if (solidPtr->GetEntityType()=="G4Para")
{ const G4Para* const paraPtr
= static_cast<const G4Para*>(solidPtr);
ParaWrite(solidsElement,paraPtr); } else
if (solidPtr->GetEntityType()=="G4Paraboloid")
{ const G4Paraboloid* const paraboloidPtr
= static_cast<const G4Paraboloid*>(solidPtr);
ParaboloidWrite(solidsElement,paraboloidPtr); } else
if (solidPtr->GetEntityType()=="G4Polycone")
{ const G4Polycone* const polyconePtr
= static_cast<const G4Polycone*>(solidPtr);
PolyconeWrite(solidsElement,polyconePtr); } else
if (solidPtr->GetEntityType()=="G4GenericPolycone")
{ const G4GenericPolycone* const genpolyconePtr
= static_cast<const G4GenericPolycone*>(solidPtr);
GenericPolyconeWrite(solidsElement,genpolyconePtr); } else
if (solidPtr->GetEntityType()=="G4Polyhedra")
{ const G4Polyhedra* const polyhedraPtr
= static_cast<const G4Polyhedra*>(solidPtr);
PolyhedraWrite(solidsElement,polyhedraPtr); } else
if (solidPtr->GetEntityType()=="G4Sphere")
{ const G4Sphere* const spherePtr
= static_cast<const G4Sphere*>(solidPtr);
SphereWrite(solidsElement,spherePtr); } else
if (solidPtr->GetEntityType()=="G4TessellatedSolid")
{ const G4TessellatedSolid* const tessellatedPtr
= static_cast<const G4TessellatedSolid*>(solidPtr);
TessellatedWrite(solidsElement,tessellatedPtr); } else
if (solidPtr->GetEntityType()=="G4Tet")
{ const G4Tet* const tetPtr
= static_cast<const G4Tet*>(solidPtr);
TetWrite(solidsElement,tetPtr); } else
if (solidPtr->GetEntityType()=="G4Torus")
{ const G4Torus* const torusPtr
= static_cast<const G4Torus*>(solidPtr);
TorusWrite(solidsElement,torusPtr); } else
if (solidPtr->GetEntityType()=="G4GenericTrap")
{ const G4GenericTrap* const gtrapPtr
= static_cast<const G4GenericTrap*>(solidPtr);
GenTrapWrite(solidsElement,gtrapPtr); } else
if (solidPtr->GetEntityType()=="G4Trap")
{ const G4Trap* const trapPtr
= static_cast<const G4Trap*>(solidPtr);
TrapWrite(solidsElement,trapPtr); } else
if (solidPtr->GetEntityType()=="G4Trd")
{ const G4Trd* const trdPtr
= static_cast<const G4Trd*>(solidPtr);
TrdWrite(solidsElement,trdPtr); } else
if (solidPtr->GetEntityType()=="G4Tubs")
{ const G4Tubs* const tubePtr
= static_cast<const G4Tubs*>(solidPtr);
TubeWrite(solidsElement,tubePtr); } else
if (solidPtr->GetEntityType()=="G4CutTubs")
{ const G4CutTubs* const cuttubePtr
= static_cast<const G4CutTubs*>(solidPtr);
CutTubeWrite(solidsElement,cuttubePtr); } else
if (solidPtr->GetEntityType()=="G4TwistedBox")
{ const G4TwistedBox* const twistedboxPtr
= static_cast<const G4TwistedBox*>(solidPtr);
TwistedboxWrite(solidsElement,twistedboxPtr); } else
if (solidPtr->GetEntityType()=="G4TwistedTrap")
{ const G4TwistedTrap* const twistedtrapPtr
= static_cast<const G4TwistedTrap*>(solidPtr);
TwistedtrapWrite(solidsElement,twistedtrapPtr); } else
if (solidPtr->GetEntityType()=="G4TwistedTrd")
{ const G4TwistedTrd* const twistedtrdPtr
= static_cast<const G4TwistedTrd*>(solidPtr);
TwistedtrdWrite(solidsElement,twistedtrdPtr); } else
if (solidPtr->GetEntityType()=="G4TwistedTubs")
{ const G4TwistedTubs* const twistedtubsPtr
= static_cast<const G4TwistedTubs*>(solidPtr);
TwistedtubsWrite(solidsElement,twistedtubsPtr); }
else
{
G4String error_msg = "Unknown solid: " + solidPtr->GetName()