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 &)
G4String	ConvertToString (G4int ival)
G4String	ConvertToString (G4double dval)

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

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

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().

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

Referenced by DefineMatrix().

DefineMatrix()

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

Definition at line 80 of file G4GDMLEvaluator.cc.

{
  const G4int size = (G4int)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]);
      }
    }
  }
}

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

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

Referenced by EvaluateInteger(), GetConstant(), and GetVariable().

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

Referenced by SolveBrackets().

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

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

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

Referenced by GetConstant(), GetVariable(), 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);
}

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

Referenced by Evaluate().

---

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

• G4GDMLEvaluator.hh
• G4GDMLEvaluator.cc