ClhepEvaluator.cc

Go to the documentation of this file.

#include <ext/alloc_traits.h>
#include <iostream>
#include <string>
#include <vector>

#include "CLHEP/Evaluator/Evaluator.h"
#include "DetectorDescription/Core/interface/ClhepEvaluator.h"
#include "FWCore/MessageLogger/interface/MessageLogger.h"
#include "FWCore/Utilities/interface/Exception.h"

ClhepEvaluator::ClhepEvaluator()
{ 
  // enable standard mathematical funtions
  evaluator_.setStdMath();
  
  // set Geant4 compatible units
  evaluator_.setSystemOfUnits(1.e+3, 1./1.60217733e-25, 1.e+9, 1./1.60217733e-10,
                  1.0, 1.0, 1.0);
   
  // set some global vars, which are in fact known by Clhep::SystemOfUnits
  // but are NOT set in CLHEP::Evaluator ...
  evaluator_.setVariable("mum","1.e-3*mm");
  evaluator_.setVariable("fm","1.e-15*meter");
}

ClhepEvaluator::~ClhepEvaluator()
{ 
  clear();
}

void
dd_exchange_value( std::vector<std::string> & vars,
           std::vector<std::string> & vals, 
           const std::string & var,
           const std::string & val )
{
  std::vector<std::string>::iterator it(vars.begin()), ed(vars.end());
  std::vector<std::string>::size_type count(0);
  for (; it != ed; ++it) {
    if ( *it == var) {
      // a potential memory leak below! But CLHEP::Evaluator should take care about it!!
      vals[count] = val;
      break;
    }
    ++count;
  }
}

void
ClhepEvaluator::set( const std::string & ns, const std::string & name,
             const std::string & exprValue )
{
  checkname(ns); // fancy characters in ns or name ??
  checkname(name);
  std::string newVar;
  std::string newVal;
  prepare(ns,name,exprValue,newVar,newVal);
  evaluator_.setVariable(newVar.c_str(), newVal.c_str());
  switch(evaluator_.status()) {
  case HepTool::Evaluator::WARNING_EXISTING_VARIABLE:
    dd_exchange_value(variables_,values_,newVar,newVal);
    break;
  case HepTool::Evaluator::OK:
  case HepTool::Evaluator::WARNING_EXISTING_FUNCTION:
  case HepTool::Evaluator::WARNING_BLANK_STRING:
    variables_.emplace_back(newVar);
    values_.emplace_back(newVal);
    break;
  default:
    std::cout << "set-var: ns=" << ns << " nm=" << name << " val=" << exprValue << std::endl;
    evaluator_.print_error();
    throwex(ns,name,exprValue,"can't set parameter !");
  }
}

void
ClhepEvaluator::set(const std::string & n, const std::string & v)
{
  evaluator_.setVariable(n.c_str(),v.c_str());
  switch(evaluator_.status()) {
  case HepTool::Evaluator::WARNING_EXISTING_VARIABLE:
    dd_exchange_value(variables_,values_,n,v);
    break;
  case HepTool::Evaluator::OK:
  case HepTool::Evaluator::WARNING_EXISTING_FUNCTION:
  case HepTool::Evaluator::WARNING_BLANK_STRING:
    variables_.emplace_back(n);
    values_.emplace_back(v);
    break;
  default:
    std::cout << "set-varname=" << n << " val=" << v << std::endl;
    evaluator_.print_error();
    throwex("",n,v,"can't set parameter !");
  }  
}

double
ClhepEvaluator::eval(const std::string & ns, const std::string & expr)
{   
  // eval does not store std::strings in the values_!
  // eval throws if it can't evaluate!
  std::string pseudo("(evaluating)");
  std::string prepared;
  
  prepare(ns,pseudo,expr, pseudo,prepared);
  
  double result = evaluator_.evaluate(prepared.c_str());
  if(evaluator_.status()!=HepTool::Evaluator::OK) {
    std::cout << "expr: " << prepared << std::endl;
    std::cout << "------";
    for (int i=0; i<evaluator_.error_position(); ++i) std::cout << "-";
    std::cout << "^" << std::endl;
    evaluator_.print_error();
    throwex(ns,prepared,expr,"can't evaluate: " + expr + std::string("!"));
  }
  
  return result;
}

double
ClhepEvaluator::eval(const char * expression)
{
  double result = evaluator_.evaluate(expression);
  if (evaluator_.status()!=HepTool::Evaluator::OK) {
    std::cout << "expr: " << expression << std::endl;
    std::cout << "------";
    for (int i=0; i<evaluator_.error_position(); ++i) std::cout << "-";
    std::cout << "^" << std::endl;
    evaluator_.print_error();
    throwex("",expression,"","can't evaluate: " + std::string(expression) + std::string("!"));   
  }
  return result;
}

bool
ClhepEvaluator::isDefined( const std::string & ns, //< current namespace
               const std::string & name //< name of the variable inside current namespace
               ) 
{
  std::string newVar; 
  std::string newVal;
  prepare(ns,name,"0", newVar,newVal);
  return evaluator_.findVariable(newVar.c_str());
}        

void ClhepEvaluator::clear()
{
  // clear the dictionary
  evaluator_.clear();
  
  // clear the cache of values & variable-names   
  variables_.clear();
  values_.clear();
}

void
ClhepEvaluator::prepare(const std::string & ns, 
            const std::string & name, 
            const std::string & exprValue,
            std::string & nameResult, 
            std::string & valResult) const
{
  static const std::string sep("___"); // separator between ns and name
  // SOME SPAGHETTI CODE ...
  //  break it down into some addional member functions ... 
  
  // the name and namespaces are not checked for 'forbidden' symbols like [,],: ...
  nameResult = ns + sep + name;
  
  // scan the expression std::string and remove [ ], and insert the current namespace if it's missing
  std::string temp;
  
  // 2 pass for simplicity (which is NOT efficient ...)
  // pass 1: find variables without namespace, e.g. [abcd], and mark them
  // pass 2: remove [ ] & ( exchange ':' with '_' | add the namespace at marked variables )
  
  std::string::size_type sz = exprValue.size();
  std::string::size_type idx =0;
  bool insideBracket = false;
  bool nsFound = false;
  int varCount=0; // count the variables from 1,2,3,...
  std::vector<int> hasNs(1); // marked[i]=1 ... variable number i has a namespace attached with ':'
  
  while(idx<sz) 
  {
    switch(exprValue[idx]) 
    {
    case '[':     
      if (nsFound || insideBracket) 
      { // oops, something went wrong. simply throw!
    throwex(ns,name,exprValue,
        "found a ':' outside '[..]' , or too many '[' !",idx); 
      }
      insideBracket=true; 
      ++varCount;
      break;
    case ']':
      if (!insideBracket) 
      {
    throwex(ns,name,exprValue,"too many ']' !",idx);
      }
      insideBracket=false;  
      if (nsFound) 
      {
    nsFound=false; // reset
    hasNs.emplace_back(1);
      }
      else 
      {
    hasNs.emplace_back(0);   
      } 
      break;
    case ':':
      if ( (!insideBracket) || nsFound ) 
      { // oops, a namespace outside [] or a 2nd ':' inside []! !
    throwex(ns,name,exprValue,
        "found a ':' outside '[..]' , or multiple ':' inside '[..]'",idx);
      }          
      nsFound=true;
      break;
    default:
      ;
    } // switch
    ++idx;
  } // while(sz)
  
  // status after pass 1 must be: every [ ] is closed and no ':' 
  if ( insideBracket || nsFound ) {
    throwex(ns,name,exprValue,
        "'[..]' not closed , or ':' outside of '[..]'",idx);
  }
  
  // Pass 2: now remove all '[' ']', replace ':' or add 'ns' + '_'
  //sz = exprValue.size();
  idx=0;
  varCount=0;
  //bool ommit = false;
  while (idx<sz) 
  {
    switch(exprValue[idx]) 
    {
    case '[':
      ++varCount;
      if ( !hasNs[varCount] ) 
      {
    valResult = valResult + ns + sep;
      }  
      break;
    case ']':
      break;
    case ':':
      valResult = valResult + sep;
      break;
    default:
      valResult = valResult + exprValue[idx];
    } // switch
    ++idx;
  } // while 
}          

void
ClhepEvaluator::throwex( const std::string & ns, 
             const std::string & name, 
             const std::string & expr,
             const std::string & reason,
             int idx ) const
{
  std::string er = std::string("ClhepEvaluator ERROR: ") + reason + std::string("\n")
    + std::string(" nmspace=") + ns 
    + std::string("\n varname=") + name
    + std::string("\n exp=") + expr
    + std::string("\n  at=") + expr.substr(0,idx);
  throw cms::Exception("DDException") << er;
}                 

void
ClhepEvaluator::checkname( const std::string & s ) const
{
  // '['   ']'   ' '  ':'   are forbidden for names and namespaces of parameters
  std::string::size_type sz = s.size();
  while(sz) 
  {
    --sz;
    //bool stop = false;
    switch (s[sz]) 
    {
    case ']':
    case '[':
    case ' ':
    case ':':
    case '\n':
    case '\t':
      // case '.':
    case '&':
    case '*':
    case '+':
    case '-':
    case '/':
    case '^':
      std::string e = std::string("ClhepEvaluator ERROR: forbidden character '")
      + s[sz] + std::string("' found in '") + s + std::string("' !");
    throw cms::Exception("DDException") << e;         
    break;  
    }
  }
}