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

Import Geant4 10.3.0.beta source tree

Browse Source
This commit is contained in:
Gabriele Cosmo
2016-06-30 14:12:05 +02:00
parent a654a7ab1f
commit 4ec577e5c4
2021 changed files with 100995 additions and 78277 deletions
Download Patch File Download Diff File Expand all files Collapse all files
source/persistency/gdml/src/G4GDMLMessenger.cc
+15 -1
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id: G4GDMLMessenger.cc 89381 2015-04-08 15:32:47Z gcosmo $
// $Id: G4GDMLMessenger.cc 96673 2016-04-29 12:08:20Z gcosmo $
//
//
// class G4GDMLMessenger Implementation
@@ -85,6 +85,13 @@ G4GDMLMessenger::G4GDMLMessenger(G4GDMLParser* myPars)
EcutsCmd->SetDefaultValue(false);
EcutsCmd->AvailableForStates(G4State_Idle);
SDCmd = new G4UIcmdWithABool("/persistency/gdml/export_SD",this);
SDCmd->SetGuidance("Enable export of SD associated");
SDCmd->SetGuidance("to logical volumes.");
SDCmd->SetParameterName("export_SD",false);
SDCmd->SetDefaultValue(false);
SDCmd->AvailableForStates(G4State_Idle);
ClearCmd = new G4UIcmdWithoutParameter("/persistency/gdml/clear",this);
ClearCmd->SetGuidance("Clear geometry (before reading a new one from GDML).");
ClearCmd->AvailableForStates(G4State_Idle);
@@ -98,6 +105,7 @@ G4GDMLMessenger::~G4GDMLMessenger()
delete TopVolCmd;
delete RegionCmd;
delete EcutsCmd;
delete SDCmd;
delete persistencyDir;
delete gdmlDir;
}
@@ -123,6 +131,12 @@ void G4GDMLMessenger::SetNewValue(G4UIcommand* command, G4String newValue)
myParser->SetEnergyCutsExport(mode);
}
if( command == SDCmd )
{
G4bool mode = SDCmd->GetNewBoolValue(newValue);
myParser->SetSDExport(mode);
}
if( command == TopVolCmd )
{
topvol = G4LogicalVolumeStore::GetInstance()->GetVolume(newValue);
source/persistency/gdml/src/G4GDMLParser.cc
+13 -1
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id: G4GDMLParser.cc 90041 2015-05-11 09:46:06Z gcosmo $
// $Id: G4GDMLParser.cc 96190 2016-03-29 08:07:36Z gcosmo $
//
//
// class G4GDMLParser Implementation
@@ -121,6 +121,9 @@ void G4GDMLParser::ImportRegions()
{
const G4String& cvalue = raux->value;
const G4String& cunit = raux->unit;
if (G4UnitDefinition::GetCategory(cunit)!="Length") {
G4Exception("G4GDMLParser::ImportRegions()", "InvalidRead",
FatalException, "Invalid unit for length!"); }
G4double cut = eval.Evaluate(cvalue) * G4UnitDefinition::GetValueOf(cunit);
pcuts->SetProductionCut(cut,"proton");
} else
@@ -128,6 +131,9 @@ void G4GDMLParser::ImportRegions()
{
const G4String& cvalue = raux->value;
const G4String& cunit = raux->unit;
if (G4UnitDefinition::GetCategory(cunit)!="Length") {
G4Exception("G4GDMLParser::ImportRegions()", "InvalidRead",
FatalException, "Invalid unit for length!"); }
G4double cut = eval.Evaluate(cvalue) * G4UnitDefinition::GetValueOf(cunit);
pcuts->SetProductionCut(cut,"e-");
} else
@@ -135,6 +141,9 @@ void G4GDMLParser::ImportRegions()
{
const G4String& cvalue = raux->value;
const G4String& cunit = raux->unit;
if (G4UnitDefinition::GetCategory(cunit)!="Length") {
G4Exception("G4GDMLParser::ImportRegions()", "InvalidRead",
FatalException, "Invalid unit for length!"); }
G4double cut = eval.Evaluate(cvalue) * G4UnitDefinition::GetValueOf(cunit);
pcuts->SetProductionCut(cut,"e+");
} else
@@ -142,6 +151,9 @@ void G4GDMLParser::ImportRegions()
{
const G4String& cvalue = raux->value;
const G4String& cunit = raux->unit;
if (G4UnitDefinition::GetCategory(cunit)!="Length") {
G4Exception("G4GDMLParser::ImportRegions()", "InvalidRead",
FatalException, "Invalid unit for length!"); }
G4double cut = eval.Evaluate(cvalue) * G4UnitDefinition::GetValueOf(cunit);
pcuts->SetProductionCut(cut,"gamma");
} else
source/persistency/gdml/src/G4GDMLReadDefine.cc
+12 -4
View File
@@ -23,7 +23,7 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4GDMLReadDefine.cc 92977 2015-09-24 14:56:22Z gcosmo $
// $Id: G4GDMLReadDefine.cc 96190 2016-03-29 08:07:36Z gcosmo $
//
// class G4GDMLReadDefine Implementation
//
@@ -299,7 +299,11 @@ G4GDMLReadDefine::PositionRead(const xercesc::DOMElement* const positionElement)
const G4String attValue = Transcode(attribute->getValue());
if (attName=="name") { name = GenerateName(attValue); } else
if (attName=="unit") { unit = G4UnitDefinition::GetValueOf(attValue); } else
if (attName=="unit") { unit = G4UnitDefinition::GetValueOf(attValue);
if (G4UnitDefinition::GetCategory(attValue)!="Length") {
G4Exception("G4GDMLReadDefine::PositionRead()", "InvalidRead",
FatalException, "Invalid unit for length!"); }
} else
if (attName=="x") { position.setX(eval.Evaluate(attValue)); } else
if (attName=="y") { position.setY(eval.Evaluate(attValue)); } else
if (attName=="z") { position.setZ(eval.Evaluate(attValue)); }
@@ -338,8 +342,12 @@ G4GDMLReadDefine::RotationRead(const xercesc::DOMElement* const rotationElement)
const G4String attValue = Transcode(attribute->getValue());
if (attName=="name") { name = GenerateName(attValue); } else
if (attName=="unit") { unit = G4UnitDefinition::GetValueOf(attValue); } else
if (attName=="x") { rotation.setX(eval.Evaluate(attValue)); } else
if (attName=="unit") { unit = G4UnitDefinition::GetValueOf(attValue);
if (G4UnitDefinition::GetCategory(attValue)!="Angle") {
G4Exception("G4GDMLReadDefine::RotationRead()", "InvalidRead",
FatalException, "Invalid unit for angle!"); }
} else
if (attName=="x") { rotation.setX(eval.Evaluate(attValue)); } else
if (attName=="y") { rotation.setY(eval.Evaluate(attValue)); } else
if (attName=="z") { rotation.setZ(eval.Evaluate(attValue)); }
}
source/persistency/gdml/src/G4GDMLReadMaterials.cc
+27 -6
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id: G4GDMLReadMaterials.cc 89243 2015-03-27 16:24:39Z gcosmo $
// $Id: G4GDMLReadMaterials.cc 96190 2016-03-29 08:07:36Z gcosmo $
// GEANT4 tag $ Name:$
//
// class G4GDMLReadMaterials Implementation
@@ -81,7 +81,11 @@ G4GDMLReadMaterials::AtomRead(const xercesc::DOMElement* const atomElement)
const G4String attValue = Transcode(attribute->getValue());
if (attName=="value") { value = eval.Evaluate(attValue); } else
if (attName=="unit") { unit = G4UnitDefinition::GetValueOf(attValue); }
if (attName=="unit") {unit = G4UnitDefinition::GetValueOf(attValue);
if (G4UnitDefinition::GetCategory(attValue)!="Molar mass") {
G4Exception("G4GDMLReadMaterials::AtomRead()", "InvalidRead",
FatalException, "Invalid unit for atomic mass!"); }
}
}
return value*unit;
@@ -151,7 +155,12 @@ G4double G4GDMLReadMaterials::DRead(const xercesc::DOMElement* const DElement)
const G4String attValue = Transcode(attribute->getValue());
if (attName=="value") { value = eval.Evaluate(attValue); } else
if (attName=="unit") { unit = G4UnitDefinition::GetValueOf(attValue); }
if (attName=="unit") {
unit = G4UnitDefinition::GetValueOf(attValue);
if (G4UnitDefinition::GetCategory(attValue)!="Volumic Mass") {
G4Exception("G4GDMLReadMaterials::DRead()", "InvalidRead",
FatalException, "Invalid unit for density!"); }
}
}
return value*unit;
@@ -185,7 +194,11 @@ G4double G4GDMLReadMaterials::PRead(const xercesc::DOMElement* const PElement)
const G4String attValue = Transcode(attribute->getValue());
if (attName=="value") { value = eval.Evaluate(attValue); } else
if (attName=="unit") { unit = G4UnitDefinition::GetValueOf(attValue); }
if (attName=="unit") { unit = G4UnitDefinition::GetValueOf(attValue);
if (G4UnitDefinition::GetCategory(attValue)!="Pressure") {
G4Exception("G4GDMLReadMaterials::PRead()", "InvalidRead",
FatalException, "Invalid unit for pressure!"); }
}
}
return value*unit;
@@ -219,7 +232,11 @@ G4double G4GDMLReadMaterials::TRead(const xercesc::DOMElement* const TElement)
const G4String attValue = Transcode(attribute->getValue());
if (attName=="value") { value = eval.Evaluate(attValue); } else
if (attName=="unit") { unit = G4UnitDefinition::GetValueOf(attValue); }
if (attName=="unit") { unit = G4UnitDefinition::GetValueOf(attValue);
if (G4UnitDefinition::GetCategory(attValue)!="Temperature") {
G4Exception("G4GDMLReadMaterials::TRead()", "InvalidRead",
FatalException, "Invalid unit for temperature!"); }
}
}
return value*unit;
@@ -253,7 +270,11 @@ G4double G4GDMLReadMaterials::MEERead(const xercesc::DOMElement* const PElement)
const G4String attValue = Transcode(attribute->getValue());
if (attName=="value") { value = eval.Evaluate(attValue); } else
if (attName=="unit") { unit = G4UnitDefinition::GetValueOf(attValue); }
if (attName=="unit") { unit = G4UnitDefinition::GetValueOf(attValue);
if (G4UnitDefinition::GetCategory(attValue)!="Energy") {
G4Exception("G4GDMLReadMaterials::MEERead()", "InvalidRead",
FatalException, "Invalid unit for energy!"); }
}
}
return value*unit;
source/persistency/gdml/src/G4GDMLReadParamvol.cc
+111 -23
View File
@@ -23,7 +23,7 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4GDMLReadParamvol.cc 89243 2015-03-27 16:24:39Z gcosmo $
// $Id: G4GDMLReadParamvol.cc 96190 2016-03-29 08:07:36Z gcosmo $
//
// class G4GDMLReadParamvol Implementation
//
@@ -76,7 +76,11 @@ Box_dimensionsRead( const xercesc::DOMElement* const element,
const G4String attName = Transcode(attribute->getName());
const G4String attValue = Transcode(attribute->getValue());
if (attName=="lunit") { lunit = G4UnitDefinition::GetValueOf(attValue); } else
if (attName=="lunit") { lunit = G4UnitDefinition::GetValueOf(attValue);
if (G4UnitDefinition::GetCategory(attValue)!="Length") {
G4Exception("G4GDMLReadParamvol::Box_dimensionsRead()", "InvalidRead",
FatalException, "Invalid unit for length!"); }
} else
if (attName=="x") { parameter.dimension[0] = eval.Evaluate(attValue); } else
if (attName=="y") { parameter.dimension[1] = eval.Evaluate(attValue); } else
if (attName=="z") { parameter.dimension[2] = eval.Evaluate(attValue); }
@@ -115,7 +119,11 @@ Trd_dimensionsRead( const xercesc::DOMElement* const element,
const G4String attName = Transcode(attribute->getName());
const G4String attValue = Transcode(attribute->getValue());
if (attName=="lunit") { lunit = G4UnitDefinition::GetValueOf(attValue); } else
if (attName=="lunit") { lunit = G4UnitDefinition::GetValueOf(attValue);
if (G4UnitDefinition::GetCategory(attValue)!="Length") {
G4Exception("G4GDMLReadParamvol::Trd_dimensionsRead()", "InvalidRead",
FatalException, "Invalid unit for length!"); }
} else
if (attName=="x1") { parameter.dimension[0]=eval.Evaluate(attValue); } else
if (attName=="x2") { parameter.dimension[1]=eval.Evaluate(attValue); } else
if (attName=="y1") { parameter.dimension[2]=eval.Evaluate(attValue); } else
@@ -160,9 +168,17 @@ Trap_dimensionsRead( const xercesc::DOMElement* const element,
const G4String attValue = Transcode(attribute->getValue());
if (attName=="lunit")
{ lunit = G4UnitDefinition::GetValueOf(attValue); } else
{ lunit = G4UnitDefinition::GetValueOf(attValue);
if (G4UnitDefinition::GetCategory(attValue)!="Length") {
G4Exception("G4GDMLReadParamvol::Trap_dimensionsRead()", "InvalidRead",
FatalException, "Invalid unit for length!"); }
} else
if (attName=="aunit")
{ aunit = G4UnitDefinition::GetValueOf(attValue); } else
{ aunit = G4UnitDefinition::GetValueOf(attValue);
if (G4UnitDefinition::GetCategory(attValue)!="Angle") {
G4Exception("G4GDMLReadParamvol::Trap_dimensionsRead()", "InvalidRead",
FatalException, "Invalid unit for angle!"); }
} else
if (attName=="z")
{ parameter.dimension[0] = eval.Evaluate(attValue); } else
if (attName=="theta")
@@ -230,9 +246,17 @@ Tube_dimensionsRead( const xercesc::DOMElement* const element,
const G4String attValue = Transcode(attribute->getValue());
if (attName=="lunit")
{ lunit = G4UnitDefinition::GetValueOf(attValue); } else
{ lunit = G4UnitDefinition::GetValueOf(attValue);
if (G4UnitDefinition::GetCategory(attValue)!="Length") {
G4Exception("G4GDMLReadParamvol::Tube_dimensionsRead()", "InvalidRead",
FatalException, "Invalid unit for length!"); }
} else
if (attName=="aunit")
{ aunit = G4UnitDefinition::GetValueOf(attValue); } else
{ aunit = G4UnitDefinition::GetValueOf(attValue);
if (G4UnitDefinition::GetCategory(attValue)!="Angle") {
G4Exception("G4GDMLReadParamvol::Tube_dimensionsRead()", "InvalidRead",
FatalException, "Invalid unit for angle!"); }
} else
if (attName=="InR")
{ parameter.dimension[0] = eval.Evaluate(attValue); } else
if (attName=="OutR")
@@ -282,9 +306,17 @@ Cone_dimensionsRead( const xercesc::DOMElement* const element,
const G4String attValue = Transcode(attribute->getValue());
if (attName=="lunit")
{ lunit = G4UnitDefinition::GetValueOf(attValue); } else
{ lunit = G4UnitDefinition::GetValueOf(attValue);
if (G4UnitDefinition::GetCategory(attValue)!="Length") {
G4Exception("G4GDMLReadParamvol::Cone_dimensionsRead()", "InvalidRead",
FatalException, "Invalid unit for length!"); }
} else
if (attName=="aunit")
{ aunit = G4UnitDefinition::GetValueOf(attValue); } else
{ aunit = G4UnitDefinition::GetValueOf(attValue);
if (G4UnitDefinition::GetCategory(attValue)!="Angle") {
G4Exception("G4GDMLReadParamvol::Cone_dimensions()", "InvalidRead",
FatalException, "Invalid unit for angle!"); }
} else
if (attName=="rmin1")
{ parameter.dimension[0] = eval.Evaluate(attValue); } else
if (attName=="rmax1")
@@ -340,9 +372,17 @@ Sphere_dimensionsRead( const xercesc::DOMElement* const element,
const G4String attValue = Transcode(attribute->getValue());
if (attName=="lunit")
{ lunit = G4UnitDefinition::GetValueOf(attValue); } else
{ lunit = G4UnitDefinition::GetValueOf(attValue);
if (G4UnitDefinition::GetCategory(attValue)!="Length") {
G4Exception("G4GDMLReadParamvol::Sphere_dimensionsRead()", "InvalidRead",
FatalException, "Invalid unit for length!"); }
} else
if (attName=="aunit")
{ aunit = G4UnitDefinition::GetValueOf(attValue); } else
{ aunit = G4UnitDefinition::GetValueOf(attValue);
if (G4UnitDefinition::GetCategory(attValue)!="Angle") {
G4Exception("G4GDMLReadParamvol::Sphere_dimensionsRead()", "InvalidRead",
FatalException, "Invalid unit for angle!"); }
} else
if (attName=="rmin")
{ parameter.dimension[0] = eval.Evaluate(attValue); } else
if (attName=="rmax")
@@ -393,7 +433,11 @@ Orb_dimensionsRead( const xercesc::DOMElement* const element,
const G4String attName = Transcode(attribute->getName());
const G4String attValue = Transcode(attribute->getValue());
if (attName=="lunit") { lunit = G4UnitDefinition::GetValueOf(attValue); } else
if (attName=="lunit") { lunit = G4UnitDefinition::GetValueOf(attValue); }
if (G4UnitDefinition::GetCategory(attValue)!="Length") {
G4Exception("G4GDMLReadParamvol::Orb_dimensionsRead()", "InvalidRead",
FatalException, "Invalid unit for length!"); }
else
if (attName=="r") { parameter.dimension[0] = eval.Evaluate(attValue); }
}
@@ -430,9 +474,17 @@ Torus_dimensionsRead( const xercesc::DOMElement* const element,
const G4String attValue = Transcode(attribute->getValue());
if (attName=="lunit")
{ lunit = G4UnitDefinition::GetValueOf(attValue); } else
{ lunit = G4UnitDefinition::GetValueOf(attValue);
if (G4UnitDefinition::GetCategory(attValue)!="Length") {
G4Exception("G4GDMLReadParamvol::Torus_dimensionsRead()", "InvalidRead",
FatalException, "Invalid unit for length!"); }
} else
if (attName=="aunit")
{ aunit = G4UnitDefinition::GetValueOf(attValue); } else
{ aunit = G4UnitDefinition::GetValueOf(attValue);
if (G4UnitDefinition::GetCategory(attValue)!="Angle") {
G4Exception("G4GDMLReadParamvol::Torus_dimensionsRead()", "InvalidRead",
FatalException, "Invalid unit for angle!"); }
} else
if (attName=="rmin")
{ parameter.dimension[0] = eval.Evaluate(attValue); } else
if (attName=="rmax")
@@ -480,7 +532,11 @@ Ellipsoid_dimensionsRead( const xercesc::DOMElement* const element,
const G4String attValue = Transcode(attribute->getValue());
if (attName=="lunit")
{ lunit = G4UnitDefinition::GetValueOf(attValue); } else
{ lunit = G4UnitDefinition::GetValueOf(attValue);
if (G4UnitDefinition::GetCategory(attValue)!="Length") {
G4Exception("G4GDMLReadParamvol::Ellipsoid_dimensionsRead()", "InvalidRead",
FatalException, "Invalid unit for length!"); }
} else
if (attName=="ax")
{ parameter.dimension[0] = eval.Evaluate(attValue); } else
if (attName=="by")
@@ -530,9 +586,17 @@ Para_dimensionsRead( const xercesc::DOMElement* const element,
const G4String attValue = Transcode(attribute->getValue());
if (attName=="lunit")
{ lunit = G4UnitDefinition::GetValueOf(attValue); } else
{ lunit = G4UnitDefinition::GetValueOf(attValue);
if (G4UnitDefinition::GetCategory(attValue)!="Length") {
G4Exception("G4GDMLReadParamvol::Para_dimensionsRead()", "InvalidRead",
FatalException, "Invalid unit for length!"); }
} else
if (attName=="aunit")
{ aunit = G4UnitDefinition::GetValueOf(attValue); } else
{ aunit = G4UnitDefinition::GetValueOf(attValue);
if (G4UnitDefinition::GetCategory(attValue)!="Angle") {
G4Exception("G4GDMLReadParamvol::Para_dimensionsRead()", "InvalidRead",
FatalException, "Invalid unit for angle!"); }
} else
if (attName=="x")
{ parameter.dimension[0] = eval.Evaluate(attValue); } else
if (attName=="y")
@@ -585,9 +649,17 @@ Hype_dimensionsRead( const xercesc::DOMElement* const element,
const G4String attValue = Transcode(attribute->getValue());
if (attName=="lunit")
{ lunit = G4UnitDefinition::GetValueOf(attValue); } else
{ lunit = G4UnitDefinition::GetValueOf(attValue);
if (G4UnitDefinition::GetCategory(attValue)!="Length") {
G4Exception("G4GDMLReadParamvol::Hype_dimensionsRead()", "InvalidRead",
FatalException, "Invalid unit for length!"); }
} else
if (attName=="aunit")
{ aunit = G4UnitDefinition::GetValueOf(attValue); } else
{ aunit = G4UnitDefinition::GetValueOf(attValue);
if (G4UnitDefinition::GetCategory(attValue)!="Angle") {
G4Exception("G4GDMLReadParamvol::Hype_dimensionsRead()", "InvalidRead",
FatalException, "Invalid unit for angle!"); }
} else
if (attName=="rmin")
{ parameter.dimension[0] = eval.Evaluate(attValue); } else
if (attName=="rmax")
@@ -639,9 +711,17 @@ Polycone_dimensionsRead( const xercesc::DOMElement* const element,
const G4String attValue = Transcode(attribute->getValue());
if (attName=="lunit")
{ lunit = G4UnitDefinition::GetValueOf(attValue); } else
{ lunit = G4UnitDefinition::GetValueOf(attValue);
if (G4UnitDefinition::GetCategory(attValue)!="Length") {
G4Exception("G4GDMLReadParamvol::Polycone_dimensionsRead()", "InvalidRead",
FatalException, "Invalid unit for length!"); }
} else
if (attName=="aunit")
{ aunit = G4UnitDefinition::GetValueOf(attValue); } else
{ aunit = G4UnitDefinition::GetValueOf(attValue);
if (G4UnitDefinition::GetCategory(attValue)!="Angle") {
G4Exception("G4GDMLReadParamvol::Polycone_dimensionsRead()", "InvalidRead",
FatalException, "Invalid unit for angle!"); }
} else
if (attName=="startPhi")
{ parameter.dimension[0] = eval.Evaluate(attValue); } else
if (attName=="openPhi")
@@ -712,9 +792,17 @@ Polyhedra_dimensionsRead( const xercesc::DOMElement* const element,
const G4String attValue = Transcode(attribute->getValue());
if (attName=="lunit")
{ lunit = G4UnitDefinition::GetValueOf(attValue); } else
{ lunit = G4UnitDefinition::GetValueOf(attValue);
if (G4UnitDefinition::GetCategory(attValue)!="Length") {
G4Exception("G4GDMLReadParamvol::Polyhedra_dimensionsRead()", "InvalidRead",
FatalException, "Invalid unit for length!"); }
} else
if (attName=="aunit")
{ aunit = G4UnitDefinition::GetValueOf(attValue); } else
{ aunit = G4UnitDefinition::GetValueOf(attValue);
if (G4UnitDefinition::GetCategory(attValue)!="Angle") {
G4Exception("G4GDMLReadParamvol::Polyhedra_dimensionsRead()", "InvalidRead",
FatalException, "Invalid unit for angle!"); }
} else
if (attName=="startPhi")
{ parameter.dimension[0] = eval.Evaluate(attValue); } else
if (attName=="openPhi")
source/persistency/gdml/src/G4GDMLReadSolids.cc
+306 -51
View File
@@ -23,7 +23,7 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4GDMLReadSolids.cc 93151 2015-10-08 11:53:10Z gcosmo $
// $Id: G4GDMLReadSolids.cc 96190 2016-03-29 08:07:36Z gcosmo $
//
// class G4GDMLReadSolids Implementation
//
@@ -47,6 +47,7 @@
#include "G4Polyhedra.hh"
#include "G4QuadrangularFacet.hh"
#include "G4ReflectedSolid.hh"
#include "G4ScaledSolid.hh"
#include "G4Sphere.hh"
#include "G4SolidStore.hh"
#include "G4SubtractionSolid.hh"
@@ -206,8 +207,13 @@ void G4GDMLReadSolids::BoxRead(const xercesc::DOMElement* const boxElement)
const G4String attName = Transcode(attribute->getName());
const G4String attValue = Transcode(attribute->getValue());
if (attName=="name") { name = GenerateName(attValue); } else
if (attName=="lunit") { lunit = G4UnitDefinition::GetValueOf(attValue); } else
if (attName=="name") { name = GenerateName(attValue); } else
if (attName=="lunit") { lunit = G4UnitDefinition::GetValueOf(attValue);
if (G4UnitDefinition::GetCategory(attValue)!="Length") {
G4Exception("G4GDMLReadSolids::BoxRead()", "InvalidRead",
FatalException, "Invalid unit for length!"); }
}
else
if (attName=="x") { x = eval.Evaluate(attValue); } else
if (attName=="y") { y = eval.Evaluate(attValue); } else
if (attName=="z") { z = eval.Evaluate(attValue); }
@@ -256,9 +262,17 @@ void G4GDMLReadSolids::ConeRead(const xercesc::DOMElement* const coneElement)
const G4String attName = Transcode(attribute->getName());
const G4String attValue = Transcode(attribute->getValue());
if (attName=="name") { name = GenerateName(attValue); } else
if (attName=="lunit") { lunit = G4UnitDefinition::GetValueOf(attValue); } else
if (attName=="aunit") { aunit = G4UnitDefinition::GetValueOf(attValue); } else
if (attName=="name") { name = GenerateName(attValue); } else
if (attName=="lunit") { lunit = G4UnitDefinition::GetValueOf(attValue);
if (G4UnitDefinition::GetCategory(attValue)!="Length") {
G4Exception("G4GDMLReadSolids::ConeRead()", "InvalidRead",
FatalException, "Invalid unit for length!"); }
} else
if (attName=="aunit") { aunit = G4UnitDefinition::GetValueOf(attValue);
if (G4UnitDefinition::GetCategory(attValue)!="Angle") {
G4Exception("G4GDMLReadSolids::ConeRead()", "InvalidRead",
FatalException, "Invalid unit for angle!"); }
} else
if (attName=="rmin1") { rmin1 = eval.Evaluate(attValue); } else
if (attName=="rmax1") { rmax1 = eval.Evaluate(attValue); } else
if (attName=="rmin2") { rmin2 = eval.Evaluate(attValue); } else
@@ -313,7 +327,11 @@ ElconeRead(const xercesc::DOMElement* const elconeElement)
const G4String attValue = Transcode(attribute->getValue());
if (attName=="name") { name = GenerateName(attValue); } else
if (attName=="lunit") { lunit = G4UnitDefinition::GetValueOf(attValue); } else
if (attName=="lunit") { lunit = G4UnitDefinition::GetValueOf(attValue);
if (G4UnitDefinition::GetCategory(attValue)!="Length") {
G4Exception("G4GDMLReadSolids::ElconeRead()", "InvalidRead",
FatalException, "Invalid unit for length!"); }
} else
if (attName=="dx") { dx = eval.Evaluate(attValue); } else
if (attName=="dy") { dy = eval.Evaluate(attValue); } else
if (attName=="zmax") { zmax = eval.Evaluate(attValue); } else
@@ -361,7 +379,11 @@ EllipsoidRead(const xercesc::DOMElement* const ellipsoidElement)
const G4String attValue = Transcode(attribute->getValue());
if (attName=="name") { name = GenerateName(attValue); } else
if (attName=="lunit") { lunit = G4UnitDefinition::GetValueOf(attValue); } else
if (attName=="lunit") { lunit = G4UnitDefinition::GetValueOf(attValue);
if (G4UnitDefinition::GetCategory(attValue)!="Length") {
G4Exception("G4GDMLReadSolids::EllipsoidRead()", "InvalidRead",
FatalException, "Invalid unit for length!"); }
} else
if (attName=="ax") { ax = eval.Evaluate(attValue); } else
if (attName=="by") { by = eval.Evaluate(attValue); } else
if (attName=="cz") { cz = eval.Evaluate(attValue); } else
@@ -411,7 +433,11 @@ EltubeRead(const xercesc::DOMElement* const eltubeElement)
const G4String attValue = Transcode(attribute->getValue());
if (attName=="name") { name = GenerateName(attValue); } else
if (attName=="lunit") { lunit = G4UnitDefinition::GetValueOf(attValue); } else
if (attName=="lunit") { lunit = G4UnitDefinition::GetValueOf(attValue);
if (G4UnitDefinition::GetCategory(attValue)!="Length") {
G4Exception("G4GDMLReadSolids::EltubeRead()", "InvalidRead",
FatalException, "Invalid unit for length!"); }
} else
if (attName=="dx") { dx = eval.Evaluate(attValue); } else
if (attName=="dy") { dy = eval.Evaluate(attValue); } else
if (attName=="dz") { dz = eval.Evaluate(attValue); }
@@ -453,7 +479,11 @@ void G4GDMLReadSolids::XtruRead(const xercesc::DOMElement* const xtruElement)
const G4String attValue = Transcode(attribute->getValue());
if (attName=="name") { name = GenerateName(attValue); } else
if (attName=="lunit") { lunit = G4UnitDefinition::GetValueOf(attValue); }
if (attName=="lunit") { lunit = G4UnitDefinition::GetValueOf(attValue);
if (G4UnitDefinition::GetCategory(attValue)!="Length") {
G4Exception("G4GDMLReadSolids::XtruRead()", "InvalidRead",
FatalException, "Invalid unit for length!"); }
}
}
std::vector<G4TwoVector> twoDimVertexList;
@@ -518,8 +548,16 @@ void G4GDMLReadSolids::HypeRead(const xercesc::DOMElement* const hypeElement)
const G4String attValue = Transcode(attribute->getValue());
if (attName=="name") { name = GenerateName(attValue); } else
if (attName=="lunit") { lunit = G4UnitDefinition::GetValueOf(attValue); } else
if (attName=="aunit") { aunit = G4UnitDefinition::GetValueOf(attValue); } else
if (attName=="lunit") { lunit = G4UnitDefinition::GetValueOf(attValue);
if (G4UnitDefinition::GetCategory(attValue)!="Length") {
G4Exception("G4GDMLReadSolids::HypeRead()", "InvalidRead",
FatalException, "Invalid unit for length!"); }
} else
if (attName=="aunit") { aunit = G4UnitDefinition::GetValueOf(attValue);
if (G4UnitDefinition::GetCategory(attValue)!="Angle") {
G4Exception("G4GDMLReadSolids::HypeRead()", "InvalidRead",
FatalException, "Invalid unit for angle!"); }
} else
if (attName=="rmin") { rmin = eval.Evaluate(attValue); } else
if (attName=="rmax") { rmax = eval.Evaluate(attValue); } else
if (attName=="inst") { inst = eval.Evaluate(attValue); } else
@@ -717,7 +755,11 @@ void G4GDMLReadSolids::OrbRead(const xercesc::DOMElement* const orbElement)
const G4String attValue = Transcode(attribute->getValue());
if (attName=="name") { name = GenerateName(attValue); } else
if (attName=="lunit") { lunit = G4UnitDefinition::GetValueOf(attValue); } else
if (attName=="lunit") { lunit = G4UnitDefinition::GetValueOf(attValue);
if (G4UnitDefinition::GetCategory(attValue)!="Length") {
G4Exception("G4GDMLReadSolids::OrbRead()", "InvalidRead",
FatalException, "Invalid unit for length!"); }
} else
if (attName=="r") { r = eval.Evaluate(attValue); }
}
@@ -762,9 +804,17 @@ void G4GDMLReadSolids::ParaRead(const xercesc::DOMElement* const paraElement)
const G4String attValue = Transcode(attribute->getValue());
if (attName=="name") { name = GenerateName(attValue); } else
if (attName=="lunit") { lunit = G4UnitDefinition::GetValueOf(attValue); } else
if (attName=="aunit") { aunit = G4UnitDefinition::GetValueOf(attValue); } else
if (attName=="x") { x = eval.Evaluate(attValue); } else
if (attName=="lunit") { lunit = G4UnitDefinition::GetValueOf(attValue);
if (G4UnitDefinition::GetCategory(attValue)!="Length") {
G4Exception("G4GDMLReadSolids::ParaRead()", "InvalidRead",
FatalException, "Invalid unit for length!"); }
} else
if (attName=="aunit") { aunit = G4UnitDefinition::GetValueOf(attValue);
if (G4UnitDefinition::GetCategory(attValue)!="Angle") {
G4Exception("G4GDMLReadSolids::ParaRead()", "InvalidRead",
FatalException, "Invalid unit for angle!"); }
} else
if (attName=="x") { x = eval.Evaluate(attValue); } else
if (attName=="y") { y = eval.Evaluate(attValue); } else
if (attName=="z") { z = eval.Evaluate(attValue); } else
if (attName=="alpha") { alpha = eval.Evaluate(attValue); } else
@@ -815,7 +865,11 @@ ParaboloidRead(const xercesc::DOMElement* const paraElement)
const G4String attValue = Transcode(attribute->getValue());
if (attName=="name") { name = GenerateName(attValue); } else
if (attName=="lunit") { lunit = G4UnitDefinition::GetValueOf(attValue); } else
if (attName=="lunit") { lunit = G4UnitDefinition::GetValueOf(attValue);
if (G4UnitDefinition::GetCategory(attValue)!="Length") {
G4Exception("G4GDMLReadSolids::ParaboloidRead()", "InvalidRead",
FatalException, "Invalid unit for length!"); }
} else
if (attName=="rlo") { rlo = eval.Evaluate(attValue); } else
if (attName=="rhi") { rhi = eval.Evaluate(attValue); } else
if (attName=="dz") { dz = eval.Evaluate(attValue); }
@@ -861,8 +915,16 @@ PolyconeRead(const xercesc::DOMElement* const polyconeElement)
const G4String attValue = Transcode(attribute->getValue());
if (attName=="name") { name = GenerateName(attValue); } else
if (attName=="lunit") { lunit = G4UnitDefinition::GetValueOf(attValue); } else
if (attName=="aunit") { aunit = G4UnitDefinition::GetValueOf(attValue); } else
if (attName=="lunit") { lunit = G4UnitDefinition::GetValueOf(attValue);
if (G4UnitDefinition::GetCategory(attValue)!="Length") {
G4Exception("G4GDMLReadSolids::PolyconeRead()", "InvalidRead",
FatalException, "Invalid unit for length!"); }
} else
if (attName=="aunit") { aunit = G4UnitDefinition::GetValueOf(attValue);
if (G4UnitDefinition::GetCategory(attValue)!="Angle") {
G4Exception("G4GDMLReadSolids::PolyconeRead()", "InvalidRead",
FatalException, "Invalid unit for angle!"); }
} else
if (attName=="startphi") { startphi = eval.Evaluate(attValue); }else
if (attName=="deltaphi") { deltaphi = eval.Evaluate(attValue); }
}
@@ -944,8 +1006,16 @@ GenericPolyconeRead(const xercesc::DOMElement* const polyconeElement)
const G4String attValue = Transcode(attribute->getValue());
if (attName=="name") { name = GenerateName(attValue); } else
if (attName=="lunit") { lunit = G4UnitDefinition::GetValueOf(attValue); } else
if (attName=="aunit") { aunit = G4UnitDefinition::GetValueOf(attValue); } else
if (attName=="lunit") { lunit = G4UnitDefinition::GetValueOf(attValue);
if (G4UnitDefinition::GetCategory(attValue)!="Length") {
G4Exception("G4GDMLReadSolids::GenericPolyconeRead()", "InvalidRead",
FatalException, "Invalid unit for length!"); }
} else
if (attName=="aunit") { aunit = G4UnitDefinition::GetValueOf(attValue);
if (G4UnitDefinition::GetCategory(attValue)!="Angle") {
G4Exception("G4GDMLReadSolids::GenericPolyconeRead()", "InvalidRead",
FatalException, "Invalid unit for angle!"); }
} else
if (attName=="startphi") { startphi = eval.Evaluate(attValue); }else
if (attName=="deltaphi") { deltaphi = eval.Evaluate(attValue); }
}
@@ -1023,8 +1093,16 @@ PolyhedraRead(const xercesc::DOMElement* const polyhedraElement)
const G4String attValue = Transcode(attribute->getValue());
if (attName=="name") { name = GenerateName(attValue); } else
if (attName=="lunit") { lunit = G4UnitDefinition::GetValueOf(attValue); } else
if (attName=="aunit") { aunit = G4UnitDefinition::GetValueOf(attValue); } else
if (attName=="lunit") { lunit = G4UnitDefinition::GetValueOf(attValue);
if (G4UnitDefinition::GetCategory(attValue)!="Length") {
G4Exception("G4GDMLReadSolids::PolyhedraRead()", "InvalidRead",
FatalException, "Invalid unit for length!"); }
} else
if (attName=="aunit") { aunit = G4UnitDefinition::GetValueOf(attValue);
if (G4UnitDefinition::GetCategory(attValue)!="Angle") {
G4Exception("G4GDMLReadSolids::PolyhedraRead()", "InvalidRead",
FatalException, "Invalid unit for angle!"); }
} else
if (attName=="startphi") { startphi = eval.Evaluate(attValue); } else
if (attName=="deltaphi") { deltaphi = eval.Evaluate(attValue); } else
if (attName=="numsides") { numsides = eval.EvaluateInteger(attValue); }
@@ -1108,8 +1186,16 @@ GenericPolyhedraRead(const xercesc::DOMElement* const polyhedraElement)
const G4String attValue = Transcode(attribute->getValue());
if (attName=="name") { name = GenerateName(attValue); } else
if (attName=="lunit") { lunit = G4UnitDefinition::GetValueOf(attValue); } else
if (attName=="aunit") { aunit = G4UnitDefinition::GetValueOf(attValue); } else
if (attName=="lunit") { lunit = G4UnitDefinition::GetValueOf(attValue);
if (G4UnitDefinition::GetCategory(attValue)!="Length") {
G4Exception("G4GDMLReadSolids::GenericPolyhedraRead()", "InvalidRead",
FatalException, "Invalid unit for length!"); }
} else
if (attName=="aunit") { aunit = G4UnitDefinition::GetValueOf(attValue);
if (G4UnitDefinition::GetCategory(attValue)!="Angle") {
G4Exception("G4GDMLReadSolids::GenericPolyhedraRead()", "InvalidRead",
FatalException, "Invalid unit for angle!"); }
} else
if (attName=="startphi") { startphi = eval.Evaluate(attValue); } else
if (attName=="deltaphi") { deltaphi = eval.Evaluate(attValue); } else
if (attName=="numsides") { numsides = eval.EvaluateInteger(attValue); }
@@ -1198,8 +1284,12 @@ QuadrangularRead(const xercesc::DOMElement* const quadrangularElement)
if (attName=="vertex4")
{ vertex4 = GetPosition(GenerateName(attValue)); } else
if (attName=="lunit")
{ lunit = G4UnitDefinition::GetValueOf(attValue); } else
if (attName=="type")
{ lunit = G4UnitDefinition::GetValueOf(attValue);
if (G4UnitDefinition::GetCategory(attValue)!="Length") {
G4Exception("G4GDMLReadSolids::QuadrangularRead()", "InvalidRead",
FatalException, "Invalid unit for length!"); }
} else
if (attName=="type")
{ if (attValue=="RELATIVE") { type = RELATIVE; } }
}
@@ -1242,8 +1332,16 @@ ReflectedSolidRead(const xercesc::DOMElement* const reflectedSolidElement)
const G4String attValue = Transcode(attribute->getValue());
if (attName=="name") { name = GenerateName(attValue); } else
if (attName=="lunit") { lunit = G4UnitDefinition::GetValueOf(attValue); } else
if (attName=="aunit") { aunit = G4UnitDefinition::GetValueOf(attValue); } else
if (attName=="lunit") { lunit = G4UnitDefinition::GetValueOf(attValue);
if (G4UnitDefinition::GetCategory(attValue)!="Length") {
G4Exception("G4GDMLReadSolids::ReflectedSolidRead()", "InvalidRead",
FatalException, "Invalid unit for length!"); }
} else
if (attName=="aunit") { aunit = G4UnitDefinition::GetValueOf(attValue);
if (G4UnitDefinition::GetCategory(attValue)!="Angle") {
G4Exception("G4GDMLReadSolids::ReflectedSolidRead()", "InvalidRead",
FatalException, "Invalid unit for angle!"); }
} else
if (attName=="solid") { solid = GenerateName(attValue); } else
if (attName=="sx") { scale.setX(eval.Evaluate(attValue)); } else
if (attName=="sy") { scale.setY(eval.Evaluate(attValue)); } else
@@ -1265,6 +1363,74 @@ ReflectedSolidRead(const xercesc::DOMElement* const reflectedSolidElement)
new G4ReflectedSolid(name,GetSolid(solid),transform);
}
void G4GDMLReadSolids::
ScaledSolidRead(const xercesc::DOMElement* const scaledSolidElement)
{
G4String name;
G4VSolid* solid=0;
G4ThreeVector scale(1.0,1.0,1.0);
const xercesc::DOMNamedNodeMap* const attributes
= scaledSolidElement->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::ScaledSolidRead()",
"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 = scaledSolidElement->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::ScaledSolidRead()",
"InvalidRead", FatalException, "No child found!");
return;
}
const G4String tag = Transcode(child->getTagName());
if (tag=="solidref")
{ solid = GetSolid(GenerateName(RefRead(child))); }
else if (tag=="scale")
{ VectorRead(child,scale); }
else if (tag=="scaleref")
{ scale = GetScale(GenerateName(RefRead(child))); }
else
{
G4String error_msg = "Unknown tag in scaled solid: " + tag;
G4Exception("G4GDMLReadSolids::ScaledSolidRead()", "ReadError",
FatalException, error_msg);
return;
}
}
G4Scale3D transform = G4Scale3D(scale.x(),scale.y(),scale.z());
new G4ScaledSolid(name, solid ,transform);
}
G4ExtrudedSolid::ZSection G4GDMLReadSolids::
SectionRead(const xercesc::DOMElement* const sectionElement,G4double lunit)
{
@@ -1345,8 +1511,16 @@ SphereRead(const xercesc::DOMElement* const sphereElement)
const G4String attValue = Transcode(attribute->getValue());
if (attName=="name") { name = GenerateName(attValue); } else
if (attName=="lunit") { lunit = G4UnitDefinition::GetValueOf(attValue); } else
if (attName=="aunit") { aunit = G4UnitDefinition::GetValueOf(attValue); } else
if (attName=="lunit") { lunit = G4UnitDefinition::GetValueOf(attValue);
if (G4UnitDefinition::GetCategory(attValue)!="Length") {
G4Exception("G4GDMLReadSolids::SphereRead()", "InvalidRead",
FatalException, "Invalid unit for length!"); }
} else
if (attName=="aunit") { aunit = G4UnitDefinition::GetValueOf(attValue);
if (G4UnitDefinition::GetCategory(attValue)!="Angle") {
G4Exception("G4GDMLReadSolids::SphereRead()", "InvalidRead",
FatalException, "Invalid unit for angle!"); }
} else
if (attName=="rmin") { rmin = eval.Evaluate(attValue); } else
if (attName=="rmax") { rmax = eval.Evaluate(attValue); } else
if (attName=="startphi") { startphi = eval.Evaluate(attValue); } else
@@ -1457,7 +1631,11 @@ void G4GDMLReadSolids::TetRead(const xercesc::DOMElement* const tetElement)
if (attName=="name")
{ name = GenerateName(attValue); } else
if (attName=="lunit")
{ lunit = G4UnitDefinition::GetValueOf(attValue); } else
{ lunit = G4UnitDefinition::GetValueOf(attValue);
if (G4UnitDefinition::GetCategory(attValue)!="Length") {
G4Exception("G4GDMLReadSolids::TetRead()", "InvalidRead",
FatalException, "Invalid unit for length!"); }
} else
if (attName=="vertex1")
{ vertex1 = GetPosition(GenerateName(attValue)); } else
if (attName=="vertex2")
@@ -1506,8 +1684,16 @@ void G4GDMLReadSolids::TorusRead(const xercesc::DOMElement* const torusElement)
const G4String attValue = Transcode(attribute->getValue());
if (attName=="name") { name = GenerateName(attValue); } else
if (attName=="lunit") { lunit = G4UnitDefinition::GetValueOf(attValue); } else
if (attName=="aunit") { aunit = G4UnitDefinition::GetValueOf(attValue); } else
if (attName=="lunit") { lunit = G4UnitDefinition::GetValueOf(attValue);
if (G4UnitDefinition::GetCategory(attValue)!="Length") {
G4Exception("G4GDMLReadSolids::TorusRead()", "InvalidRead",
FatalException, "Invalid unit for length!"); }
} else
if (attName=="aunit") { aunit = G4UnitDefinition::GetValueOf(attValue);
if (G4UnitDefinition::GetCategory(attValue)!="Angle") {
G4Exception("G4GDMLReadSolids::TorusRead()", "InvalidRead",
FatalException, "Invalid unit for angle!"); }
} else
if (attName=="rmin") { rmin = eval.Evaluate(attValue); } else
if (attName=="rmax") { rmax = eval.Evaluate(attValue); } else
if (attName=="rtor") { rtor = eval.Evaluate(attValue); } else
@@ -1558,7 +1744,11 @@ GenTrapRead(const xercesc::DOMElement* const gtrapElement)
const G4String attValue = Transcode(attribute->getValue());
if (attName=="name") { name = GenerateName(attValue); } else
if (attName=="lunit") { G4UnitDefinition::GetValueOf(attValue); } else
if (attName=="lunit") { G4UnitDefinition::GetValueOf(attValue);
if (G4UnitDefinition::GetCategory(attValue)!="Length") {
G4Exception("G4GDMLReadSolids::GenTrapRead()", "InvalidRead",
FatalException, "Invalid unit for length!"); }
} else
if (attName=="dz") { dz = eval.Evaluate(attValue); } else
if (attName=="v1x") { v1x = eval.Evaluate(attValue); } else
if (attName=="v1y") { v1y = eval.Evaluate(attValue); } else
@@ -1632,8 +1822,16 @@ void G4GDMLReadSolids::TrapRead(const xercesc::DOMElement* const trapElement)
const G4String attValue = Transcode(attribute->getValue());
if (attName=="name") { name = GenerateName(attValue); } else
if (attName=="lunit") { lunit = G4UnitDefinition::GetValueOf(attValue); } else
if (attName=="aunit") { aunit = G4UnitDefinition::GetValueOf(attValue); } else
if (attName=="lunit") { lunit = G4UnitDefinition::GetValueOf(attValue);
if (G4UnitDefinition::GetCategory(attValue)!="Length") {
G4Exception("G4GDMLReadSolids::TrapRead()", "InvalidRead",
FatalException, "Invalid unit for length!"); }
} else
if (attName=="aunit") { aunit = G4UnitDefinition::GetValueOf(attValue);
if (G4UnitDefinition::GetCategory(attValue)!="Angle") {
G4Exception("G4GDMLReadSolids::TrapRead()", "InvalidRead",
FatalException, "Invalid unit for angle!"); }
} else
if (attName=="z") { z = eval.Evaluate(attValue); } else
if (attName=="theta") { theta = eval.Evaluate(attValue); } else
if (attName=="phi") { phi = eval.Evaluate(attValue); } else
@@ -1695,7 +1893,11 @@ void G4GDMLReadSolids::TrdRead(const xercesc::DOMElement* const trdElement)
const G4String attValue = Transcode(attribute->getValue());
if (attName=="name") { name = GenerateName(attValue); } else
if (attName=="lunit") { lunit = G4UnitDefinition::GetValueOf(attValue); } else
if (attName=="lunit") { lunit = G4UnitDefinition::GetValueOf(attValue);
if (G4UnitDefinition::GetCategory(attValue)!="Length") {
G4Exception("G4GDMLReadSolids::TrdRead()", "InvalidRead",
FatalException, "Invalid unit for length!"); }
} else
if (attName=="x1") { x1 = eval.Evaluate(attValue); } else
if (attName=="x2") { x2 = eval.Evaluate(attValue); } else
if (attName=="y1") { y1 = eval.Evaluate(attValue); } else
@@ -1751,7 +1953,11 @@ TriangularRead(const xercesc::DOMElement* const triangularElement)
if (attName=="vertex3")
{ vertex3 = GetPosition(GenerateName(attValue)); } else
if (attName=="lunit")
{ lunit = G4UnitDefinition::GetValueOf(attValue); } else
{ lunit = G4UnitDefinition::GetValueOf(attValue);
if (G4UnitDefinition::GetCategory(attValue)!="Length") {
G4Exception("G4GDMLReadSolids::TriangularRead()", "InvalidRead",
FatalException, "Invalid unit for length!"); }
} else
if (attName=="type")
{ if (attValue=="RELATIVE") { type = RELATIVE; } }
}
@@ -1794,8 +2000,16 @@ void G4GDMLReadSolids::TubeRead(const xercesc::DOMElement* const tubeElement)
const G4String attValue = Transcode(attribute->getValue());
if (attName=="name") { name = GenerateName(attValue); } else
if (attName=="lunit") { lunit = G4UnitDefinition::GetValueOf(attValue); } else
if (attName=="aunit") { aunit = G4UnitDefinition::GetValueOf(attValue); } else
if (attName=="lunit") { lunit = G4UnitDefinition::GetValueOf(attValue);
if (G4UnitDefinition::GetCategory(attValue)!="Length") {
G4Exception("G4GDMLReadSolids::TubeRead()", "InvalidRead",
FatalException, "Invalid unit for length!"); }
} else
if (attName=="aunit") { aunit = G4UnitDefinition::GetValueOf(attValue);
if (G4UnitDefinition::GetCategory(attValue)!="Angle") {
G4Exception("G4GDMLReadSolids::TubeRead()", "InvalidRead",
FatalException, "Invalid unit for angle!"); }
} else
if (attName=="rmin") { rmin = eval.Evaluate(attValue); } else
if (attName=="rmax") { rmax = eval.Evaluate(attValue); } else
if (attName=="z") { z = eval.Evaluate(attValue); } else
@@ -1849,8 +2063,16 @@ void G4GDMLReadSolids::CutTubeRead(const xercesc::DOMElement* const cuttubeEleme
const G4String attValue = Transcode(attribute->getValue());
if (attName=="name") { name = GenerateName(attValue); } else
if (attName=="lunit") { lunit = G4UnitDefinition::GetValueOf(attValue); } else
if (attName=="aunit") { aunit = G4UnitDefinition::GetValueOf(attValue); } else
if (attName=="lunit") { lunit = G4UnitDefinition::GetValueOf(attValue);
if (G4UnitDefinition::GetCategory(attValue)!="Length") {
G4Exception("G4GDMLReadSolids::CutTubeRead()", "InvalidRead",
FatalException, "Invalid unit for length!"); }
} else
if (attName=="aunit") { aunit = G4UnitDefinition::GetValueOf(attValue);
if (G4UnitDefinition::GetCategory(attValue)!="Angle") {
G4Exception("G4GDMLReadSolids::CutTubeRead()", "InvalidRead",
FatalException, "Invalid unit for angle!"); }
} else
if (attName=="rmin") { rmin = eval.Evaluate(attValue); } else
if (attName=="rmax") { rmax = eval.Evaluate(attValue); } else
if (attName=="z") { z = eval.Evaluate(attValue); } else
@@ -1909,8 +2131,16 @@ TwistedboxRead(const xercesc::DOMElement* const twistedboxElement)
const G4String attValue = Transcode(attribute->getValue());
if (attName=="name") { name = GenerateName(attValue); } else
if (attName=="lunit") { lunit = G4UnitDefinition::GetValueOf(attValue); } else
if (attName=="aunit") { aunit = G4UnitDefinition::GetValueOf(attValue); } else
if (attName=="lunit") { lunit = G4UnitDefinition::GetValueOf(attValue);
if (G4UnitDefinition::GetCategory(attValue)!="Length") {
G4Exception("G4GDMLReadSolids::TwistedBoxRead()", "InvalidRead",
FatalException, "Invalid unit for length!"); }
} else
if (attName=="aunit") { aunit = G4UnitDefinition::GetValueOf(attValue);
if (G4UnitDefinition::GetCategory(attValue)!="Angle") {
G4Exception("G4GDMLReadSolids::TwistedboxRead()", "InvalidRead",
FatalException, "Invalid unit for angle!"); }
} else
if (attName=="PhiTwist") { PhiTwist = eval.Evaluate(attValue); } else
if (attName=="x") { x = eval.Evaluate(attValue); } else
if (attName=="y") { y = eval.Evaluate(attValue); } else
@@ -1967,8 +2197,16 @@ TwistedtrapRead(const xercesc::DOMElement* const twistedtrapElement)
const G4String attValue = Transcode(attribute->getValue());
if (attName=="name") { name = GenerateName(attValue); } else
if (attName=="lunit") { lunit = G4UnitDefinition::GetValueOf(attValue); } else
if (attName=="aunit") { aunit = G4UnitDefinition::GetValueOf(attValue); } else
if (attName=="lunit") { lunit = G4UnitDefinition::GetValueOf(attValue);
if (G4UnitDefinition::GetCategory(attValue)!="Length") {
G4Exception("G4GDMLReadSolids::TwistedtrapRead()", "InvalidRead",
FatalException, "Invalid unit for length!"); }
} else
if (attName=="aunit") { aunit = G4UnitDefinition::GetValueOf(attValue);
if (G4UnitDefinition::GetCategory(attValue)!="Angle") {
G4Exception("G4GDMLReadSolids::TwistedtrapRead()", "InvalidRead",
FatalException, "Invalid unit for angle!"); }
} else
if (attName=="PhiTwist") { PhiTwist = eval.Evaluate(attValue); } else
if (attName=="z") { z = eval.Evaluate(attValue); } else
if (attName=="Theta") { Theta = eval.Evaluate(attValue); } else
@@ -2035,8 +2273,16 @@ TwistedtrdRead(const xercesc::DOMElement* const twistedtrdElement)
const G4String attValue = Transcode(attribute->getValue());
if (attName=="name") { name = GenerateName(attValue); } else
if (attName=="lunit") { lunit = G4UnitDefinition::GetValueOf(attValue); } else
if (attName=="aunit") { aunit = G4UnitDefinition::GetValueOf(attValue); } else
if (attName=="lunit") { lunit = G4UnitDefinition::GetValueOf(attValue);
if (G4UnitDefinition::GetCategory(attValue)!="Length") {
G4Exception("G4GDMLReadSolids::TwistedtrdRead()", "InvalidRead",
FatalException, "Invalid unit for length!"); }
} else
if (attName=="aunit") { aunit = G4UnitDefinition::GetValueOf(attValue);
if (G4UnitDefinition::GetCategory(attValue)!="Angle") {
G4Exception("G4GDMLReadSolids::TwistedtrdRead()", "InvalidRead",
FatalException, "Invalid unit for angle!"); }
} else
if (attName=="x1") { x1 = eval.Evaluate(attValue); } else
if (attName=="x2") { x2 = eval.Evaluate(attValue); } else
if (attName=="y1") { y1 = eval.Evaluate(attValue); } else
@@ -2091,8 +2337,16 @@ TwistedtubsRead(const xercesc::DOMElement* const twistedtubsElement)
const G4String attValue = Transcode(attribute->getValue());
if (attName=="name") { name = GenerateName(attValue); } else
if (attName=="lunit") { lunit = G4UnitDefinition::GetValueOf(attValue); } else
if (attName=="aunit") { aunit = G4UnitDefinition::GetValueOf(attValue); } else
if (attName=="lunit") { lunit = G4UnitDefinition::GetValueOf(attValue);
if (G4UnitDefinition::GetCategory(attValue)!="Length") {
G4Exception("G4GDMLReadSolids::TwistedtubsRead()", "InvalidRead",
FatalException, "Invalid unit for length!"); }
} else
if (attName=="aunit") { aunit = G4UnitDefinition::GetValueOf(attValue);
if (G4UnitDefinition::GetCategory(attValue)!="Angle") {
G4Exception("G4GDMLReadSolids::TwistedtubsRead()", "InvalidRead",
FatalException, "Invalid unit for angle!"); }
} else
if (attName=="twistedangle") { twistedangle=eval.Evaluate(attValue); } else
if (attName=="endinnerrad") { endinnerrad=eval.Evaluate(attValue); } else
if (attName=="endouterrad") { endouterrad=eval.Evaluate(attValue); } else
@@ -2371,6 +2625,7 @@ void G4GDMLReadSolids::SolidsRead(const xercesc::DOMElement* const solidsElement
if (tag=="polyhedra") { PolyhedraRead(child); } else
if (tag=="genericPolyhedra") { GenericPolyhedraRead(child); } else
if (tag=="reflectedSolid") { ReflectedSolidRead(child); } else
if (tag=="scaledSolid") { ScaledSolidRead(child); } else
if (tag=="sphere") { SphereRead(child); } else
if (tag=="subtraction") { BooleanRead(child,SUBTRACTION); } else
if (tag=="tessellated") { TessellatedRead(child); } else
source/persistency/gdml/src/G4GDMLReadStructure.cc
+11 -3
View File
@@ -23,7 +23,7 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4GDMLReadStructure.cc 91689 2015-07-31 09:58:27Z gcosmo $
// $Id: G4GDMLReadStructure.cc 96190 2016-03-29 08:07:36Z gcosmo $
//
// class G4GDMLReadStructure Implementation
//
@@ -156,7 +156,11 @@ DivisionvolRead(const xercesc::DOMElement* const divisionvolElement)
const G4String attValue = Transcode(attribute->getValue());
if (attName=="name") { name = attValue; } else
if (attName=="unit") { unit = G4UnitDefinition::GetValueOf(attValue); } else
if (attName=="unit") { unit = G4UnitDefinition::GetValueOf(attValue);
if (G4UnitDefinition::GetCategory(attValue)!="Length") {
G4Exception("G4GDMLReadStructure::DivisionvolRead()", "InvalidRead",
FatalException, "Invalid unit for length!"); }
} else
if (attName=="width") { width = eval.Evaluate(attValue); } else
if (attName=="offset") { offset = eval.Evaluate(attValue); } else
if (attName=="number") { number = eval.EvaluateInteger(attValue); } else
@@ -550,7 +554,11 @@ QuantityRead(const xercesc::DOMElement* const readElement)
const G4String attName = Transcode(attribute->getName());
const G4String attValue = Transcode(attribute->getValue());
if (attName=="unit") { unit = G4UnitDefinition::GetValueOf(attValue); } else
if (attName=="unit") { unit = G4UnitDefinition::GetValueOf(attValue);
if (G4UnitDefinition::GetCategory(attValue)!="Length") {
G4Exception("G4GDMLReadStructure::QuantityRead()", "InvalidRead",
FatalException, "Invalid unit for length!"); }
} else
if (attName=="value"){ value= eval.Evaluate(attValue); }
}
source/persistency/gdml/src/G4GDMLWrite.cc
+9 -9
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id: G4GDMLWrite.cc 89243 2015-03-27 16:24:39Z gcosmo $
// $Id: G4GDMLWrite.cc 96170 2016-03-22 09:17:29Z gcosmo $
//
// class G4GDMLWrite Implementation
//
@@ -136,9 +136,9 @@ G4String G4GDMLWrite::GenerateName(const G4String& name, const void* const ptr)
xercesc::DOMAttr* G4GDMLWrite::NewAttribute(const G4String& name,
const G4String& value)
{
xercesc::XMLString::transcode(name,tempStr,99);
xercesc::XMLString::transcode(name,tempStr,9999);
xercesc::DOMAttr* att = doc->createAttribute(tempStr);
xercesc::XMLString::transcode(value,tempStr,99);
xercesc::XMLString::transcode(value,tempStr,9999);
att->setValue(tempStr);
return att;
}
@@ -146,20 +146,20 @@ xercesc::DOMAttr* G4GDMLWrite::NewAttribute(const G4String& name,
xercesc::DOMAttr* G4GDMLWrite::NewAttribute(const G4String& name,
const G4double& value)
{
xercesc::XMLString::transcode(name,tempStr,99);
xercesc::XMLString::transcode(name,tempStr,9999);
xercesc::DOMAttr* att = doc->createAttribute(tempStr);
std::ostringstream ostream;
ostream.precision(15);
ostream << value;
G4String str = ostream.str();
xercesc::XMLString::transcode(str,tempStr,99);
xercesc::XMLString::transcode(str,tempStr,9999);
att->setValue(tempStr);
return att;
}
xercesc::DOMElement* G4GDMLWrite::NewElement(const G4String& name)
{
xercesc::XMLString::transcode(name,tempStr,99);
xercesc::XMLString::transcode(name,tempStr,9999);
return doc->createElement(tempStr);
}
@@ -185,12 +185,12 @@ G4Transform3D G4GDMLWrite::Write(const G4String& fname,
VolumeMap().clear(); // The module map is global for all modules,
// so clear it only at once!
xercesc::XMLString::transcode("LS", tempStr, 99);
xercesc::XMLString::transcode("LS", tempStr, 9999);
xercesc::DOMImplementationRegistry::getDOMImplementation(tempStr);
xercesc::XMLString::transcode("Range", tempStr, 99);
xercesc::XMLString::transcode("Range", tempStr, 9999);
xercesc::DOMImplementation* impl =
xercesc::DOMImplementationRegistry::getDOMImplementation(tempStr);
xercesc::XMLString::transcode("gdml", tempStr, 99);
xercesc::XMLString::transcode("gdml", tempStr, 9999);
doc = impl->createDocument(0,tempStr,0);
xercesc::DOMElement* gdml = doc->getDocumentElement();
source/persistency/gdml/src/G4GDMLWriteSolids.cc
+38 -1
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id: G4GDMLWriteSolids.cc 93151 2015-10-08 11:53:10Z gcosmo $
// $Id: G4GDMLWriteSolids.cc 96133 2016-03-16 22:21:17Z gcosmo $
//
// class G4GDMLWriteSolids Implementation
//
@@ -36,6 +36,7 @@
#include "G4SystemOfUnits.hh"
#include "G4BooleanSolid.hh"
#include "G4ScaledSolid.hh"
#include "G4Box.hh"
#include "G4Cons.hh"
#include "G4Ellipsoid.hh"
@@ -265,6 +266,39 @@ BooleanWrite(xercesc::DOMElement* solElement,
}
}
void G4GDMLWriteSolids::
ScaledWrite(xercesc::DOMElement* solElement,
const G4ScaledSolid* const scaled)
{
G4String tag("scaledSolid");
G4VSolid* solid = const_cast<G4VSolid*>(scaled->GetUnscaledSolid());
G4Scale3D scale = scaled->GetScaleTransform();
G4ThreeVector sclVector = G4ThreeVector(scale.xx(), scale.yy(), scale.zz());
AddSolid(solid); // Add the constituent solid!
const G4String& name = GenerateName(scaled->GetName(),scaled);
const G4String& solidref = GenerateName(solid->GetName(),solid);
xercesc::DOMElement* scaledElement = NewElement(tag);
scaledElement->setAttributeNode(NewAttribute("name",name));
xercesc::DOMElement* solidElement = NewElement("solidref");
solidElement->setAttributeNode(NewAttribute("ref",solidref));
scaledElement->appendChild(solidElement);
if ( (std::fabs(scale.xx()) > kLinearPrecision)
&& (std::fabs(scale.yy()) > kLinearPrecision)
&& (std::fabs(scale.zz()) > kLinearPrecision) )
{
ScaleWrite(scaledElement, name+"_scl", sclVector);
}
solElement->appendChild(scaledElement);
// Add the scaled solid AFTER its constituent solid!
}
void G4GDMLWriteSolids::
BoxWrite(xercesc::DOMElement* solElement, const G4Box* const box)
{
@@ -1041,6 +1075,9 @@ void G4GDMLWriteSolids::AddSolid(const G4VSolid* const solidPtr)
if (const G4BooleanSolid* const booleanPtr
= dynamic_cast<const G4BooleanSolid*>(solidPtr))
{ BooleanWrite(solidsElement,booleanPtr); } else
if (const G4ScaledSolid* const scaledPtr
= dynamic_cast<const G4ScaledSolid*>(solidPtr))
{ ScaledWrite(solidsElement,scaledPtr); } else
if (solidPtr->GetEntityType()=="G4MultiUnion")
{ const G4MultiUnion* const munionPtr
= static_cast<const G4MultiUnion*>(solidPtr);
source/persistency/gdml/src/G4GDMLWriteStructure.cc
+28 -2
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id: G4GDMLWriteStructure.cc 91789 2015-08-06 08:14:46Z gcosmo $
// $Id: G4GDMLWriteStructure.cc 96677 2016-04-29 12:20:20Z gcosmo $
//
// class G4GDMLWriteStructure Implementation
//
@@ -55,6 +55,8 @@
#include "G4Positron.hh"
#include "G4Proton.hh"
#include "G4VSensitiveDetector.hh"
G4GDMLWriteStructure::G4GDMLWriteStructure()
: G4GDMLWriteParamvol(), cexport(false)
{
@@ -527,7 +529,10 @@ TraverseVolumeTree(const G4LogicalVolume* const volumePtr, const G4int depth)
if (cexport) { ExportEnergyCuts(volumePtr); }
// Add optional energy cuts
if (sdexport) { ExportSD(volumePtr); }
// Add optional SDs
// Here write the auxiliary info
//
auxiter = auxmap.find(volumePtr);
@@ -607,3 +612,24 @@ G4GDMLWriteStructure::ExportEnergyCuts(const G4LogicalVolume* const lvol)
AddVolumeAuxiliary(eplusinfo, lvol);
AddVolumeAuxiliary(protinfo, lvol);
}
void
G4GDMLWriteStructure::SetSDExport(G4bool fsd)
{
sdexport = fsd;
}
void
G4GDMLWriteStructure::ExportSD(const G4LogicalVolume* const lvol)
{
G4VSensitiveDetector* sd = lvol->GetSensitiveDetector();
if(sd)
{
G4String SDname = sd->GetName();
G4GDMLAuxStructType SDinfo = {"SensDet", SDname, "", 0};
AddVolumeAuxiliary(SDinfo, lvol);
}
}