AGDD::ExpressionEvaluator Class Reference

#include <ExpressionEvaluator.h>

Collaboration diagram for AGDD::ExpressionEvaluator:

Public Member Functions
	ExpressionEvaluator ()
	~ExpressionEvaluator ()
bool	RegisterConstant (std::string &c, double v)
bool	RegisterPhysConstant (std::string &, const std::string &, const std::string &)
bool	RegisterExpression (std::string &c, const std::string &v)
bool	RegisterArray (std::string &c, const std::vector< double > &v)
bool	RegisterVariable (const std::string &var_name, double value)
double	EvaluateString (const std::string &str)
bool	is_delimiter (char c)
bool	is_real_variable (const std::string &var_name)
double	Eval (const std::string &expr)
double	Eval (const char *expr)
void	setFileCurrentlyParsed (const std::string &set)

Static Public Member Functions
static std::string	trim (const std::string &)
static std::vector< std::string >	tokenize (const std::string &, const std::string &)

Private Attributes
HepTool::Evaluator	m_calc
ConstantsTable	m_CTable
PhysicalConstantsTable	m_PCTable
std::string	m_fileCurrentlyParsed
std::vector< std::string >	m_real_vars

Detailed Description

Definition at line 20 of file ExpressionEvaluator.h.

Constructor & Destructor Documentation

ExpressionEvaluator()

ExpressionEvaluator::ExpressionEvaluator

(

)

Definition at line 17 of file ExpressionEvaluator.cxx.

{
  m_calc.clear();
  m_calc.setStdMath();                 // set standard constants and functions
  // Set Geant4 system of units
  m_calc.setSystemOfUnits(1.e+3, 1./1.60217733e-25, 1.e+9, 1./1.60217733e-10,1.0, 1.0, 1.0);
  m_fileCurrentlyParsed = "";
}

~ExpressionEvaluator()

ExpressionEvaluator::~ExpressionEvaluator

(

)

Definition at line 26 of file ExpressionEvaluator.cxx.

{
  m_CTable.clear();
  m_PCTable.clear();
  m_calc.clear();
}

Member Function Documentation

Eval() [1/2]

double ExpressionEvaluator::Eval

(

const char *

expr

)

Definition at line 196 of file ExpressionEvaluator.cxx.

{
  
  std::string expr = expr_mod;
  std::string::size_type start_index = 0;
  std::string::size_type end_index = 0;
  while(true)
  {
   start_index = expr.find('[', start_index); 
   if(start_index == std::string::npos) break;
   std::string::size_type boundary_index = expr.find(']', start_index);
   expr.replace(start_index,1,1,'_');
   end_index = expr.find(',', start_index);
   if(end_index != std::string::npos && end_index < boundary_index)
   {
    start_index++;
    std::string var1 = expr.substr(start_index, end_index-start_index);
    double eval1 = EvaluateString( var1 );
    std::stringstream ss1;
    std::string str1;
    ss1 << eval1;
    ss1 >> str1;
    expr.replace(start_index, end_index-start_index, str1, 0, str1.size());
   }
   else
   {
    end_index = boundary_index;
    if(end_index != std::string::npos)
    {
     start_index++;
     std::string var1 = expr.substr(start_index, end_index-start_index);
     double eval1 = EvaluateString( var1 );
     std::stringstream ss1;
     std::string str1;
     ss1 << eval1;
     ss1 >> str1;
     expr.replace(start_index, end_index-start_index, str1, 0, str1.size());
    }
   }
  }
  start_index = 0;
  end_index = 0;
  while(true)
  {
   start_index = expr.find(',', start_index);
   if(start_index == std::string::npos) break;
   expr.replace(start_index,1,1,'_');
   end_index = expr.find(']', start_index);
   start_index++;
   std::string var2 = expr.substr(start_index, end_index-start_index);
   double eval2 = EvaluateString( var2 );
   std::stringstream ss2;
   std::string str2;
   ss2 << eval2;
   ss2 >> str2;
   expr.replace(start_index, end_index-start_index, str2, 0, str2.size());
  }
  start_index = 0;
  end_index = 0;
  while(true)
  {
   start_index = expr.find(']', start_index);
   if(start_index == std::string::npos) break;
   expr.replace(start_index,1,1,'_');
  }
  double result = EvaluateString( expr );
  if( m_calc.status() != HepTool::Evaluator::OK )
  {
    std::cerr << expr << std::endl;
    for (int i=0; i<m_calc.error_position(); i++)
    {
      std::cerr << "-";
    }
    std::cerr << "^\a" << std::endl;
    m_calc.print_error();
    std::cerr << std::endl;
  }
  return result;
}

Eval() [2/2]

double ExpressionEvaluator::Eval

(

const std::string &

expr

)

Definition at line 191 of file ExpressionEvaluator.cxx.

{
  return Eval( expr.c_str() );
}

EvaluateString()

double ExpressionEvaluator::EvaluateString

(

const std::string &

str

)

Definition at line 95 of file ExpressionEvaluator.cxx.

{
 std::string str_mod = str;
  const char* c_str_mod = str.c_str(); //string to be modified with file namespace! 
  std::vector<int> variable_ends;  //variable names to be changed
  int cur_variable_end = 0;
  while(*c_str_mod)
  {
   if(is_delimiter(*c_str_mod) || isdigit(*c_str_mod))
   {
    c_str_mod++;
    cur_variable_end++;
   }
   else if(isalpha(*c_str_mod))
   {
    char variable[80];
    char* token;
    token = variable;
    *token = '\0';
    while(!is_delimiter(*c_str_mod))
    {
     *token=*c_str_mod;
     token++;
     c_str_mod++;
     cur_variable_end++;
    }
    *token = '\0';
    std::string variable_to_check = variable;
    if(is_real_variable(variable_to_check))
    {
     variable_ends.push_back(cur_variable_end);
    }
   }
   else
   {
    c_str_mod++;
    cur_variable_end++;
   }
  std::string::size_type shift = 0;
  std::string::size_type ns_length = m_fileCurrentlyParsed.size();
  for(unsigned int i=0; i<variable_ends.size(); i++)
  {
   str_mod.insert(shift+variable_ends[i],m_fileCurrentlyParsed);
   shift += ns_length;
  }
 }
 double result = m_calc.evaluate( str_mod.c_str() );
 return result;
}

is_delimiter()

bool ExpressionEvaluator::is_delimiter

(

char

c

)

Definition at line 89 of file ExpressionEvaluator.cxx.

{
 if(strchr(" ()|&=!><+-%*/^", c) || c==9 || c==0 || c=='\r' || c=='\n' || c=='\t' || c=='\0' || isspace(c)) return true;
 else return false;
}

is_real_variable()

bool ExpressionEvaluator::is_real_variable

(

const std::string &

var_name

)

Definition at line 70 of file ExpressionEvaluator.cxx.

{
 
 std::vector<std::string>::iterator start = m_real_vars.begin();
 std::vector<std::string>::iterator end = m_real_vars.end();
 std::vector<std::string>::iterator iter;
 
 iter = find(start, end, var_name);
 
 if (iter == end)
 {
  return false;
 }
 else
 {
  return true;
 }
}

RegisterArray()

bool ExpressionEvaluator::RegisterArray	(	std::string &	c,
		const std::vector< double > &	v )

Definition at line 48 of file ExpressionEvaluator.cxx.

{  
   for(unsigned int i=0; i<v.size(); i++)
   {
    double value = v[i];
    std::stringstream ss;
    std::string index;
    ss << i;
    ss >> index;
    std::string name = c+"_"+index+"_";
    RegisterVariable( name, value );       
   }
   return true;
}

RegisterConstant()

bool ExpressionEvaluator::RegisterConstant	(	std::string &	c,
		double	v )

Definition at line 33 of file ExpressionEvaluator.cxx.

{
  double value = v;
 
  if( m_calc.status() != HepTool::Evaluator::OK )
  {
    std::cerr << "Expression evaluator:: Error registering constant " << c << std::endl;
    m_calc.print_error();
    std::cout << std::endl;
    return false;
  }
 
  RegisterVariable( c, value );
  return true;
}

RegisterExpression()

bool ExpressionEvaluator::RegisterExpression	(	std::string &	c,
		const std::string &	v )

Definition at line 172 of file ExpressionEvaluator.cxx.

{
  std::string expr = "(";
  expr += text;
  expr += ")";
  double value = EvaluateString( expr );
 
  if( m_calc.status() != HepTool::Evaluator::OK )
  {
    std::cerr << "Expression evaluator:: Error registering expression " << name << std::endl;
    m_calc.print_error();
    std::cout << std::endl;
    return false;
  }
 
  RegisterVariable( name, value );
  return true;
}

RegisterPhysConstant()

bool ExpressionEvaluator::RegisterPhysConstant	(	std::string &	c,
		const std::string &	value,
		const std::string &	unit )

Definition at line 150 of file ExpressionEvaluator.cxx.

{
  std::string expr = value;
  expr += "*(";
  expr += unit;
  expr += ")";
 
  double dvalue      = EvaluateString( expr );
 
  if( m_calc.status() != HepTool::Evaluator::OK )
  {
    std::cerr << "Expression evaluator:: Error registering quantity "
              << c << std::endl;
    m_calc.print_error();
    std::cout << std::endl;
    return false;
  }
 
  RegisterVariable( c, dvalue );
  return true;
}

RegisterVariable()

bool ExpressionEvaluator::RegisterVariable	(	const std::string &	var_name,
		double	value )

Definition at line 63 of file ExpressionEvaluator.cxx.

{
 m_real_vars.push_back(var_name);
 m_calc.setVariable( var_name.c_str(), value );
 return true;
}

setFileCurrentlyParsed()

void AGDD::ExpressionEvaluator::setFileCurrentlyParsed ( const std::string & set )

inline

Definition at line 41 of file ExpressionEvaluator.h.

    {
        m_fileCurrentlyParsed = set;
    }

tokenize()

std::vector< std::string > ExpressionEvaluator::tokenize ( const std::string & sep, const std::string & expr )

static

Definition at line 297 of file ExpressionEvaluator.cxx.

{
    std::vector<std::string> tempvect;
    AGDDTokenizer aa(sep,expr);
    for (unsigned int i=0;i<aa.size();i++) tempvect.push_back(trim(aa[i]));
    return tempvect;
}

trim()

std::string ExpressionEvaluator::trim ( const std::string & s )

static

Definition at line 276 of file ExpressionEvaluator.cxx.

{
        if (s.size () == 0) return (s);
        std::string temp = s;
        std::string::size_type i;
        i = temp.find_first_not_of (' ');
        if (i == std::string::npos) return std::string();
// There is at least 1 non blank character in s.
        if (i > 0)
        {
                temp = temp.substr (i);
        }
        i = temp.find_last_not_of (' ');
        if (i < temp.size ())
        {
                temp.resize (i + 1);
        }
        return (temp);
}

Member Data Documentation

m_calc

HepTool::Evaluator AGDD::ExpressionEvaluator::m_calc

private

Definition at line 47 of file ExpressionEvaluator.h.

m_CTable

ConstantsTable AGDD::ExpressionEvaluator::m_CTable

private

Definition at line 48 of file ExpressionEvaluator.h.

m_fileCurrentlyParsed

std::string AGDD::ExpressionEvaluator::m_fileCurrentlyParsed

private

Definition at line 50 of file ExpressionEvaluator.h.

m_PCTable

PhysicalConstantsTable AGDD::ExpressionEvaluator::m_PCTable

private

Definition at line 49 of file ExpressionEvaluator.h.

m_real_vars

std::vector<std::string> AGDD::ExpressionEvaluator::m_real_vars

private

Definition at line 51 of file ExpressionEvaluator.h.

---

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

• ExpressionEvaluator.h
• ExpressionEvaluator.cxx