G4GDMLEvaluator Class Reference

#include <G4GDMLEvaluator.hh>

Public Member Functions
void	Clear ()
G4String	ConvertToString (G4double dval)
G4String	ConvertToString (G4int ival)
void	DefineConstant (const G4String &, G4double)
void	DefineMatrix (const G4String &, G4int, std::vector< G4double >)
void	DefineVariable (const G4String &, G4double)
G4double	Evaluate (const G4String &)
G4int	EvaluateInteger (const G4String &)
	G4GDMLEvaluator ()
G4double	GetConstant (const G4String &)
G4double	GetVariable (const G4String &)
G4bool	IsVariable (const G4String &) const
void	SetVariable (const G4String &, G4double)
G4String	SolveBrackets (const G4String &)

Private Attributes
G4Evaluator	eval
std::vector< G4String >	variableList

Detailed Description

Definition at line 41 of file G4GDMLEvaluator.hh.

Constructor & Destructor Documentation

G4GDMLEvaluator()

G4GDMLEvaluator::G4GDMLEvaluator

(

)

Definition at line 37 of file G4GDMLEvaluator.cc.

{
  eval.clear();
  eval.setStdMath();
  eval.setSystemOfUnits(meter, kilogram, second, ampere, kelvin, mole, candela);
}

References ampere, candela, HepTool::Evaluator::clear(), eval, kelvin, kilogram, meter, mole, second, HepTool::Evaluator::setStdMath(), and HepTool::Evaluator::setSystemOfUnits().

Member Function Documentation

Clear()

void G4GDMLEvaluator::Clear

(

)

Definition at line 45 of file G4GDMLEvaluator.cc.

{
  eval.clear();
  eval.setStdMath();
  eval.setSystemOfUnits(meter, kilogram, second, ampere, kelvin, mole, candela);
 
  variableList.clear();
}

References ampere, candela, HepTool::Evaluator::clear(), eval, kelvin, kilogram, meter, mole, second, HepTool::Evaluator::setStdMath(), HepTool::Evaluator::setSystemOfUnits(), and variableList.

Referenced by G4GDMLReadStructure::Clear().

ConvertToString() [1/2]

G4String G4GDMLEvaluator::ConvertToString

(

G4double

dval

)

Definition at line 323 of file G4GDMLEvaluator.cc.

{
  std::ostringstream os;
  os << dval;
  G4String vl = os.str();
  return vl;
}

ConvertToString() [2/2]

G4String G4GDMLEvaluator::ConvertToString

(

G4int

ival

)

Definition at line 314 of file G4GDMLEvaluator.cc.

{
  std::ostringstream os;
  os << ival;
  G4String vl = os.str();
  return vl;
}

Referenced by G4GDMLWriteStructure::ExportEnergyCuts(), and G4GDMLParser::ExportRegions().

DefineConstant()

void G4GDMLEvaluator::DefineConstant	(	const G4String &	name,
		G4double	value
	)

Definition at line 55 of file G4GDMLEvaluator.cc.

{
  if(eval.findVariable(name))
  {
    G4String error_msg = "Redefinition of constant or variable: " + name;
    G4Exception("G4GDMLEvaluator::DefineConstant()", "InvalidExpression",
                FatalException, error_msg);
  }
  eval.setVariable(name.c_str(), value);
}

References eval, FatalException, HepTool::Evaluator::findVariable(), G4Exception(), G4InuclParticleNames::name(), and HepTool::Evaluator::setVariable().

Referenced by G4GDMLReadDefine::ConstantRead(), DefineMatrix(), G4GDMLReadDefine::ExpressionRead(), and G4GDMLReadDefine::QuantityRead().

DefineMatrix()

void G4GDMLEvaluator::DefineMatrix	(	const G4String &	name,
		G4int	coldim,
		std::vector< G4double >	valueList
	)

Definition at line 80 of file G4GDMLEvaluator.cc.

{
  const G4int size = valueList.size();
 
  if(size == 0)
  {
    G4String error_msg = "Matrix '" + name + "' is empty!";
    G4Exception("G4GDMLEvaluator::DefineMatrix()", "InvalidSize",
                FatalException, error_msg);
  }
  /*
  if (size == 1)
  {
    G4String error_msg = "Matrix '" + name
                       + "' has only one element! "
                       + "Define a constant instead!!";
    G4Exception("G4GDMLEvaluator::DefineMatrix()", "InvalidSize",
                FatalException, error_msg);
  }
  */
 
  if(size % coldim != 0)
  {
    G4String error_msg = "Matrix '" + name + "' is not filled correctly!";
    G4Exception("G4GDMLEvaluator::DefineMatrix()", "InvalidSize",
                FatalException, error_msg);
  }
 
  if((size == coldim) || (coldim == 1))  // Row- or column matrix
  {
    for(G4int i = 0; i < size; ++i)
    {
      std::stringstream MatrixElementNameStream;
      MatrixElementNameStream << name << "_" << i;
      DefineConstant(MatrixElementNameStream.str(), valueList[i]);
    }
  }
  else  // Normal matrix
  {
    const G4int rowdim = size / coldim;
 
    for(G4int i = 0; i < rowdim; ++i)
    {
      for(G4int j = 0; j < coldim; ++j)
      {
        std::stringstream MatrixElementNameStream;
        MatrixElementNameStream << name << "_" << i << "_" << j;
        DefineConstant(MatrixElementNameStream.str(),
                       valueList[coldim * i + j]);
      }
    }
  }
}

References DefineConstant(), FatalException, G4Exception(), and G4InuclParticleNames::name().

Referenced by G4GDMLReadDefine::MatrixRead().

DefineVariable()

void G4GDMLEvaluator::DefineVariable	(	const G4String &	name,
		G4double	value
	)

Definition at line 67 of file G4GDMLEvaluator.cc.

{
  if(eval.findVariable(name))
  {
    G4String error_msg = "Redefinition of constant or variable: " + name;
    G4Exception("G4GDMLEvaluator::DefineVariable()", "InvalidExpression",
                FatalException, error_msg);
  }
  eval.setVariable(name.c_str(), value);
  variableList.push_back(name);
}

References eval, FatalException, HepTool::Evaluator::findVariable(), G4Exception(), G4InuclParticleNames::name(), HepTool::Evaluator::setVariable(), and variableList.

Referenced by G4GDMLReadDefine::VariableRead().

Evaluate()

G4double G4GDMLEvaluator::Evaluate

(

const G4String &

in

)

Definition at line 238 of file G4GDMLEvaluator.cc.

{
  G4String expression = SolveBrackets(in);
 
  G4double value = 0.0;
 
  if(!expression.empty())
  {
    value = eval.evaluate(expression.c_str());
 
    if(eval.status() != G4Evaluator::OK)
    {
      eval.print_error();
      G4String error_msg = "Error in expression: " + expression;
      G4Exception("G4GDMLEvaluator::Evaluate()", "InvalidExpression",
                  FatalException, error_msg);
    }
  }
  return value;
}

References eval, HepTool::Evaluator::evaluate(), FatalException, G4Exception(), HepTool::Evaluator::OK, HepTool::Evaluator::print_error(), SolveBrackets(), and HepTool::Evaluator::status().

Referenced by G4GDMLReadMaterials::AtomRead(), G4GDMLReadStructure::AxisRead(), G4GDMLReadParamvol::Box_dimensionsRead(), G4GDMLReadSolids::BoxRead(), G4GDMLReadParamvol::Cone_dimensionsRead(), G4GDMLReadSolids::ConeRead(), G4GDMLReadDefine::ConstantRead(), G4GDMLReadSolids::CutTubeRead(), G4GDMLReadStructure::DivisionvolRead(), G4GDMLReadMaterials::DRead(), G4GDMLReadSolids::ElconeRead(), G4GDMLReadMaterials::ElementRead(), G4GDMLReadParamvol::Ellipsoid_dimensionsRead(), G4GDMLReadSolids::EllipsoidRead(), G4GDMLReadSolids::EltubeRead(), EvaluateInteger(), G4GDMLReadDefine::ExpressionRead(), G4GDMLReadMaterials::FractionRead(), G4GDMLReadSolids::GenericPolyconeRead(), G4GDMLReadSolids::GenericPolyhedraRead(), G4GDMLReadSolids::GenTrapRead(), GetConstant(), GetVariable(), G4GDMLReadParamvol::Hype_dimensionsRead(), G4GDMLReadSolids::HypeRead(), G4GDMLParser::ImportRegions(), G4GDMLReadMaterials::MaterialRead(), G4GDMLReadDefine::MatrixRead(), G4GDMLReadMaterials::MEERead(), G4GDMLReadSolids::OpticalSurfaceRead(), G4GDMLReadParamvol::Orb_dimensionsRead(), G4GDMLReadSolids::OrbRead(), G4GDMLReadParamvol::Para_dimensionsRead(), G4GDMLReadSolids::ParaboloidRead(), G4GDMLReadParamvol::ParameterisedRead(), G4GDMLReadSolids::ParaRead(), G4GDMLReadParamvol::Polycone_dimensionsRead(), G4GDMLReadSolids::PolyconeRead(), G4GDMLReadParamvol::Polyhedra_dimensionsRead(), G4GDMLReadSolids::PolyhedraRead(), G4GDMLReadDefine::PositionRead(), G4GDMLReadMaterials::PRead(), G4GDMLReadStructure::QuantityRead(), G4GDMLReadDefine::QuantityRead(), G4GDMLReadSolids::ReflectedSolidRead(), G4GDMLReadDefine::RotationRead(), G4GDMLReadSolids::RZPointRead(), G4GDMLReadDefine::ScaleRead(), G4GDMLReadSolids::SectionRead(), G4GDMLReadParamvol::Sphere_dimensionsRead(), G4GDMLReadSolids::SphereRead(), G4GDMLReadParamvol::Torus_dimensionsRead(), G4GDMLReadSolids::TorusRead(), G4GDMLReadParamvol::Trap_dimensionsRead(), G4GDMLReadSolids::TrapRead(), G4GDMLReadParamvol::Trd_dimensionsRead(), G4GDMLReadSolids::TrdRead(), G4GDMLReadMaterials::TRead(), G4GDMLReadParamvol::Tube_dimensionsRead(), G4GDMLReadSolids::TubeRead(), G4GDMLReadSolids::TwistedboxRead(), G4GDMLReadSolids::TwistedtrapRead(), G4GDMLReadSolids::TwistedtrdRead(), G4GDMLReadSolids::TwistedtubsRead(), G4GDMLReadSolids::TwoDimVertexRead(), G4GDMLReadDefine::VariableRead(), G4GDMLReadDefine::VectorRead(), and G4GDMLReadSolids::ZplaneRead().

EvaluateInteger()

G4int G4GDMLEvaluator::EvaluateInteger

(

const G4String &

expression

)

Definition at line 260 of file G4GDMLEvaluator.cc.

{
  // This function is for evaluating integer expressions,
  // like loop variables and matrix indices.
  // Complains if the evaluated expression has a fractional
  // part different from zero
 
  G4double value = Evaluate(expression);
 
  G4int whole   = (G4int) value;
  G4double frac = value - (G4double) whole;
 
  if(frac != 0.0)
  {
    G4String error_msg =
      "Expression '" + expression + "' is expected to have an integer value!";
    G4Exception("G4GDMLEvaluator::EvaluateInteger()", "InvalidExpression",
                FatalException, error_msg);
  }
  return whole;
}

References Evaluate(), FatalException, and G4Exception().

Referenced by G4GDMLReadMaterials::CompositeRead(), G4GDMLReadStructure::DivisionvolRead(), G4GDMLReadSolids::GenericPolyhedraRead(), G4GDMLReadMaterials::IsotopeRead(), G4GDMLRead::LoopRead(), G4GDMLReadDefine::MatrixRead(), G4GDMLReadStructure::PhysvolRead(), G4GDMLReadSolids::PolyhedraRead(), SolveBrackets(), and G4GDMLReadStructure::Volume_contentRead().

GetConstant()

G4double G4GDMLEvaluator::GetConstant

(

const G4String &

name

)

Definition at line 283 of file G4GDMLEvaluator.cc.

{
  if(IsVariable(name))
  {
    G4String error_msg =
      "Constant '" + name + "' is not defined! It is a variable!";
    G4Exception("G4GDMLEvaluator::GetConstant()", "InvalidSetup",
                FatalException, error_msg);
  }
  if(!eval.findVariable(name))
  {
    G4String error_msg = "Constant '" + name + "' is not defined!";
    G4Exception("G4GDMLEvaluator::GetConstant()", "InvalidSetup",
                FatalException, error_msg);
  }
  return Evaluate(name);
}

References eval, Evaluate(), FatalException, HepTool::Evaluator::findVariable(), G4Exception(), IsVariable(), and G4InuclParticleNames::name().

Referenced by G4GDMLReadDefine::GetConstant().

GetVariable()

G4double G4GDMLEvaluator::GetVariable

(

const G4String &

name

)

Definition at line 302 of file G4GDMLEvaluator.cc.

{
  if(!IsVariable(name))
  {
    G4String error_msg = "Variable '" + name + "' is not a defined!";
    G4Exception("G4GDMLEvaluator::GetVariable()", "InvalidSetup",
                FatalException, error_msg);
  }
  return Evaluate(name);
}

References Evaluate(), FatalException, G4Exception(), IsVariable(), and G4InuclParticleNames::name().

Referenced by G4GDMLReadDefine::GetVariable().

IsVariable()

G4bool G4GDMLEvaluator::IsVariable

(

const G4String &

name

)

const

Definition at line 148 of file G4GDMLEvaluator.cc.

{
  const std::size_t variableCount = variableList.size();
 
  for(std::size_t i = 0; i < variableCount; ++i)
  {
    if(variableList[i] == name)
    {
      return true;
    }
  }
 
  return false;
}

References G4InuclParticleNames::name(), and variableList.

Referenced by GetConstant(), GetVariable(), G4GDMLReadDefine::IsValidID(), G4GDMLRead::LoopRead(), and SetVariable().

SetVariable()

void G4GDMLEvaluator::SetVariable	(	const G4String &	name,
		G4double	value
	)

Definition at line 136 of file G4GDMLEvaluator.cc.

{
  if(!IsVariable(name))
  {
    G4String error_msg = "Variable '" + name + "' is not defined!";
    G4Exception("G4GDMLEvaluator::SetVariable()", "InvalidSetup",
                FatalException, error_msg);
  }
  eval.setVariable(name.c_str(), value);
}

References eval, FatalException, G4Exception(), IsVariable(), G4InuclParticleNames::name(), and HepTool::Evaluator::setVariable().

Referenced by G4GDMLRead::LoopRead().

SolveBrackets()

G4String G4GDMLEvaluator::SolveBrackets

(

const G4String &

in

)

Definition at line 164 of file G4GDMLEvaluator.cc.

{
  std::string::size_type full  = in.size();
  std::string::size_type open  = in.find("[", 0);
  std::string::size_type close = in.find("]", 0);
 
  if(open == close)
  {
    return in;
  }
 
  if((open > close) || (open == std::string::npos) ||
     (close == std::string::npos))
  {
    G4String error_msg = "Bracket mismatch: " + in;
    G4Exception("G4GDMLEvaluator::SolveBrackets()", "InvalidExpression",
                FatalException, error_msg);
    return in;
  }
 
  std::string::size_type begin = open;
  std::string::size_type end   = 0;
  std::string::size_type end1  = 0;
  std::string out;
  out.append(in, 0, open);
 
  do  // Loop for all possible matrix elements in 'in'
  {
    do  // SolveBrackets for one matrix element
    {
      end  = in.find(",", begin + 1);
      end1 = in.find("]", begin + 1);
      if(end > end1)
      {
        end = end1;
      }
      if(end == std::string::npos)
      {
        end = close;
      }
 
      std::stringstream indexStream;
      indexStream << "_"
                  << EvaluateInteger(in.substr(begin + 1, end - begin - 1)) - 1;
 
      out.append(indexStream.str());
 
      begin = end;
 
    } while(end < close);
 
    if(full == close)
    {
      return out;
    }
 
    open  = in.find("[", begin);
    close = in.find("]", begin + 1);
 
    if(open == close)
    {
      out.append(in.substr(end + 1, full - end - 1));
      return out;
    }
    out.append(in.substr(end + 1, open - end - 1));
 
    begin = open;
 
  } while(close < full);
 
  return out;
}

References EvaluateInteger(), FatalException, and G4Exception().

Referenced by Evaluate(), G4GDMLRead::GenerateName(), and G4GDMLRead::GeneratePhysvolName().

Field Documentation

eval

G4Evaluator G4GDMLEvaluator::eval

private

Definition at line 63 of file G4GDMLEvaluator.hh.

Referenced by Clear(), DefineConstant(), DefineVariable(), Evaluate(), G4GDMLEvaluator(), GetConstant(), and SetVariable().

variableList

std::vector<G4String> G4GDMLEvaluator::variableList

private

Definition at line 64 of file G4GDMLEvaluator.hh.

Referenced by Clear(), DefineVariable(), and IsVariable().

---

The documentation for this class was generated from the following files:

• source/persistency/gdml/include/G4GDMLEvaluator.hh
• source/persistency/gdml/src/G4GDMLEvaluator.cc