G4GDMLEvaluator Class Reference

#include <G4GDMLEvaluator.hh>

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

Detailed Description

Definition at line 47 of file G4GDMLEvaluator.hh.

Constructor & Destructor Documentation

G4GDMLEvaluator::G4GDMLEvaluator

(

)

Definition at line 41 of file G4GDMLEvaluator.cc.

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

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

Member Function Documentation

void G4GDMLEvaluator::Clear

(

)

Definition at line 48 of file G4GDMLEvaluator.cc.

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

Referenced by G4GDMLReadStructure::Clear().

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

  variableList.clear();
}

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

Definition at line 57 of file G4GDMLEvaluator.cc.

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

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

{
   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);
}

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

Definition at line 80 of file G4GDMLEvaluator.cc.

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

Referenced by G4GDMLReadDefine::MatrixRead().

{
   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]);
        }
      }
   }
}

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

Definition at line 68 of file G4GDMLEvaluator.cc.

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

Referenced by G4GDMLReadDefine::VariableRead().

{
   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);
}

G4double G4GDMLEvaluator::Evaluate

(

const G4String &

in

)

Definition at line 213 of file G4GDMLEvaluator.cc.

References 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(), G03ColorReader::ColorRead(), 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(), 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(), G4GDMLReadSolids::QuadrangularRead(), G4GDMLReadStructure::QuantityRead(), G4GDMLReadDefine::QuantityRead(), G4GDMLReadSolids::ReflectedSolidRead(), G4GDMLReadDefine::RotationRead(), G4GDMLReadSolids::RZPointRead(), G4GDMLReadDefine::ScaleRead(), G4GDMLReadSolids::SectionRead(), G4GDMLReadParamvol::Sphere_dimensionsRead(), G4GDMLReadSolids::SphereRead(), G4GDMLReadSolids::TetRead(), G4GDMLReadParamvol::Torus_dimensionsRead(), G4GDMLReadSolids::TorusRead(), G4GDMLReadParamvol::Trap_dimensionsRead(), G4GDMLReadSolids::TrapRead(), G4GDMLReadParamvol::Trd_dimensionsRead(), G4GDMLReadSolids::TrdRead(), G4GDMLReadMaterials::TRead(), G4GDMLReadSolids::TriangularRead(), G4GDMLReadParamvol::Tube_dimensionsRead(), G4GDMLReadSolids::TubeRead(), G4GDMLReadSolids::TwistedboxRead(), G4GDMLReadSolids::TwistedtrapRead(), G4GDMLReadSolids::TwistedtrdRead(), G4GDMLReadSolids::TwistedtubsRead(), G4GDMLReadSolids::TwoDimVertexRead(), G4GDMLReadDefine::VariableRead(), G4GDMLReadDefine::VectorRead(), G4GDMLReadSolids::XtruRead(), and G4GDMLReadSolids::ZplaneRead().

{
   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;
}

G4int G4GDMLEvaluator::EvaluateInteger

(

const G4String &

expression

)

Definition at line 234 of file G4GDMLEvaluator.cc.

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

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

{
   // 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;
}

G4double G4GDMLEvaluator::GetConstant

(

const G4String &

name

)

Definition at line 256 of file G4GDMLEvaluator.cc.

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

Referenced by G4GDMLReadDefine::GetConstant().

{
   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);
}

G4double G4GDMLEvaluator::GetVariable

(

const G4String &

name

)

Definition at line 274 of file G4GDMLEvaluator.cc.

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

Referenced by G4GDMLReadDefine::GetVariable().

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

G4bool G4GDMLEvaluator::IsVariable

(

const G4String &

name

)

const

Definition at line 146 of file G4GDMLEvaluator.cc.

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

{
   const size_t variableCount = variableList.size();

   for (size_t i=0;i<variableCount;i++)
   {
      if (variableList[i] == name)  { return true; }
   }

   return false;
}

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

Definition at line 135 of file G4GDMLEvaluator.cc.

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

Referenced by G4GDMLRead::LoopRead().

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

G4String G4GDMLEvaluator::SolveBrackets

(

const G4String &

in

)

Definition at line 158 of file G4GDMLEvaluator.cc.

References G4String::append(), EvaluateInteger(), FatalException, and G4Exception().

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

{
   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;
}

---

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

• G4GDMLEvaluator.hh
• G4GDMLEvaluator.cc