G4tgrEvaluator Class Reference

#include <G4tgrEvaluator.hh>

Inheritance diagram for G4tgrEvaluator:

Public Types
enum	{   OK , WARNING_EXISTING_VARIABLE , WARNING_EXISTING_FUNCTION , WARNING_BLANK_STRING ,   ERROR_NOT_A_NAME , ERROR_SYNTAX_ERROR , ERROR_UNPAIRED_PARENTHESIS , ERROR_UNEXPECTED_SYMBOL ,   ERROR_UNKNOWN_VARIABLE , ERROR_UNKNOWN_FUNCTION , ERROR_EMPTY_PARAMETER , ERROR_CALCULATION_ERROR }

Public Member Functions
void	clear ()
std::string	error_name () const
int	error_position () const
double	evaluate (const char *expression)
bool	findFunction (const char *name, int npar) const
bool	findVariable (const char *name) const
	G4tgrEvaluator ()
void	print_error () const
void	print_error (G4int status) const
void	removeFunction (const char *name, int npar)
void	removeVariable (const char *name)
void	setFunction (const char *name, double(*fun)())
void	setFunction (const char *name, double(*fun)(double))
void	setFunction (const char *name, double(*fun)(double, double))
void	setFunction (const char *name, double(*fun)(double, double, double))
void	setFunction (const char *name, double(*fun)(double, double, double, double))
void	setFunction (const char *name, double(*fun)(double, double, double, double, double))
void	setStdMath ()
void	setSystemOfUnits (double meter=1.0, double kilogram=1.0, double second=1.0, double ampere=1.0, double kelvin=1.0, double mole=1.0, double candela=1.0)
void	setVariable (const char *name, const char *expression)
void	setVariable (const char *name, double value)
int	status () const
	~G4tgrEvaluator ()

Private Member Functions
void	AddCommonFunctions ()

Private Attributes
void *	p

Detailed Description

Definition at line 40 of file G4tgrEvaluator.hh.

Member Enumeration Documentation

anonymous enum

anonymous enum

inherited

List of possible statuses. Status of the last operation can be obtained with status(). In case if status() is an ERROR the corresponding error message can be printed with print_error().

See also

status

error_position

print_error

Enumerator
OK	Everything OK
WARNING_EXISTING_VARIABLE	Redefinition of existing variable
WARNING_EXISTING_FUNCTION	Redefinition of existing function
WARNING_BLANK_STRING	Empty input string
ERROR_NOT_A_NAME	Not allowed sysmbol in the name of variable or function
ERROR_SYNTAX_ERROR	Systax error
ERROR_UNPAIRED_PARENTHESIS	Unpaired parenthesis
ERROR_UNEXPECTED_SYMBOL	Unexpected sysbol
ERROR_UNKNOWN_VARIABLE	Non-existing variable
ERROR_UNKNOWN_FUNCTION	Non-existing function
ERROR_EMPTY_PARAMETER	Function call has empty parameter
ERROR_CALCULATION_ERROR	Error during calculation

Definition at line 38 of file Evaluator.h.

       {
    OK,                         
    WARNING_EXISTING_VARIABLE,  
    WARNING_EXISTING_FUNCTION,  
    WARNING_BLANK_STRING,       
    ERROR_NOT_A_NAME,           
    ERROR_SYNTAX_ERROR,         
    ERROR_UNPAIRED_PARENTHESIS, 
    ERROR_UNEXPECTED_SYMBOL,    
    ERROR_UNKNOWN_VARIABLE,     
    ERROR_UNKNOWN_FUNCTION,     
    ERROR_EMPTY_PARAMETER,      
    ERROR_CALCULATION_ERROR     
  };

Constructor & Destructor Documentation

G4tgrEvaluator()

G4tgrEvaluator::G4tgrEvaluator

(

)

Definition at line 36 of file G4tgrEvaluator.cc.

{
  AddCommonFunctions();
}

References AddCommonFunctions().

~G4tgrEvaluator()

G4tgrEvaluator::~G4tgrEvaluator

(

)

Definition at line 42 of file G4tgrEvaluator.cc.

{
}

Member Function Documentation

AddCommonFunctions()

void G4tgrEvaluator::AddCommonFunctions ( )

private

Definition at line 80 of file G4tgrEvaluator.cc.

{
  setFunction("sin", (*fltsin));
  setFunction("cos", (*fltcos));
  setFunction("tan", (*flttan));
  setFunction("asin", (*fltasin));
  setFunction("acos", (*fltacos));
  setFunction("atan", (*fltatan));
  setFunction("atan2", (*fltatan2));
  setFunction("sinh", (*fltsinh));
  setFunction("cosh", (*fltcosh));
  setFunction("tanh", (*flttanh));
  //  setFunction("asinh", (*fltasinh));
  //  setFunction("acosh", (*fltacosh));
  //  setFunction("atanh", (*fltatanh));
  setFunction("sqrt", (*fltsqrt));
  setFunction("exp", (*fltexp));
  setFunction("log", (*fltlog));
  setFunction("log10", (*fltlog10));
  setFunction("pow", (*fltpow));
}

References fltacos(), fltasin(), fltatan(), fltatan2(), fltcos(), fltcosh(), fltexp(), fltlog(), fltlog10(), fltpow(), fltsin(), fltsinh(), fltsqrt(), flttan(), flttanh(), and HepTool::Evaluator::setFunction().

Referenced by G4tgrEvaluator().

clear()

void HepTool::Evaluator::clear ( )

inherited

Clear all settings.

Definition at line 764 of file Evaluator.cc.

                      {
  Struct * s = (Struct *) p;
  s->theDictionary.clear();
  s->theExpression = 0;
  s->thePosition   = 0;
  s->theStatus     = OK;
  s->theResult     = 0.0;
}

References HepTool::Evaluator::OK, HepTool::Evaluator::p, and s.

Referenced by G4GDMLEvaluator::Clear(), and G4GDMLEvaluator::G4GDMLEvaluator().

error_name()

std::string HepTool::Evaluator::error_name ( ) const

inherited

get a string defining the error name

Definition at line 652 of file Evaluator.cc.

{
  char prefix[] = "Evaluator : ";
  std::ostringstream errn;
  Struct * s = (Struct *) p;
  switch (s->theStatus) {
  case ERROR_NOT_A_NAME:
    errn << prefix << "invalid name";
    break;
  case ERROR_SYNTAX_ERROR:
    errn << prefix << "syntax error";
    break;
  case ERROR_UNPAIRED_PARENTHESIS:
    errn << prefix << "unpaired parenthesis";
    break;
  case ERROR_UNEXPECTED_SYMBOL:
    errn << prefix << "unexpected symbol";
    break;
  case ERROR_UNKNOWN_VARIABLE:
    errn << prefix << "unknown variable";
    break;
  case ERROR_UNKNOWN_FUNCTION:
    errn << prefix << "unknown function";
    break;
  case ERROR_EMPTY_PARAMETER: 
    errn << prefix << "empty parameter in function call";
    break;
  case ERROR_CALCULATION_ERROR:
    errn << prefix << "calculation error";
    break;
  default:
    errn << " ";
  }
  return errn.str();
}

References HepTool::Evaluator::ERROR_CALCULATION_ERROR, HepTool::Evaluator::ERROR_EMPTY_PARAMETER, HepTool::Evaluator::ERROR_NOT_A_NAME, HepTool::Evaluator::ERROR_SYNTAX_ERROR, HepTool::Evaluator::ERROR_UNEXPECTED_SYMBOL, HepTool::Evaluator::ERROR_UNKNOWN_FUNCTION, HepTool::Evaluator::ERROR_UNKNOWN_VARIABLE, HepTool::Evaluator::ERROR_UNPAIRED_PARENTHESIS, HepTool::Evaluator::p, and s.

Referenced by HepTool::Evaluator::print_error().

error_position()

int HepTool::Evaluator::error_position ( ) const

inherited

Returns position in the input string where the problem occured.

Definition at line 638 of file Evaluator.cc.

                                    {
  return ((Struct *)(p))->thePosition - ((Struct *)(p))->theExpression;
}

References HepTool::Evaluator::p.

evaluate()

double HepTool::Evaluator::evaluate ( const char *  expression )

inherited

Evaluates the arithmetic expression given as character string. The expression may consist of numbers, variables and functions separated by arithmetic (+, - , /, *, ^, **) and logical operators (==, !=, >, >=, <, <=, &&, ||).

Parameters

expression

input expression.

Returns

result of the evaluation.

See also

status

error_position

print_error

Definition at line 613 of file Evaluator.cc.

                                                  {
  Struct * s = (Struct *)(p);
  if (s->theExpression != 0) { delete[] s->theExpression; }
  s->theExpression = 0;
  s->thePosition   = 0;
  s->theStatus     = WARNING_BLANK_STRING;
  s->theResult     = 0.0;
  if (expression != 0) {
    s->theExpression = new char[strlen(expression)+1];
    strcpy(s->theExpression, expression);
    s->theStatus = engine(s->theExpression,
              s->theExpression+strlen(expression)-1,
              s->theResult,
              s->thePosition,
              s->theDictionary);
  }
  return s->theResult;
}

References engine(), HepTool::Evaluator::p, s, and HepTool::Evaluator::WARNING_BLANK_STRING.

Referenced by G4GDMLEvaluator::Evaluate(), and G4tgrUtils::GetDouble().

findFunction()

bool HepTool::Evaluator::findFunction ( const char *  name, int  npar  ) const

inherited

Finds the function in the dictionary.

Parameters

name	name of the function to be unset.
npar	number of parameters of the function.

Returns

true if such a function exists, false otherwise.

Definition at line 734 of file Evaluator.cc.

                                                              {
  if (name == 0 || *name == '\0')    return false;
  if (npar < 0  || npar > MAX_N_PAR) return false;
  const char * pointer; int n; REMOVE_BLANKS;
  if (n == 0) return false;
  Struct * s = (Struct *)(p);
  return ((s->theDictionary).find(sss[npar]+string(pointer,n)) ==
      (s->theDictionary).end()) ? false : true;
}

References MAX_N_PAR, CLHEP::detail::n, G4InuclParticleNames::name(), HepTool::Evaluator::p, REMOVE_BLANKS, s, and sss.

findVariable()

bool HepTool::Evaluator::findVariable ( const char *  name ) const

inherited

Finds the variable in the dictionary.

Parameters

name	name of the variable.

Returns

true if such a variable exists, false otherwise.

Definition at line 723 of file Evaluator.cc.

                                                    {
  if (name == 0 || *name == '\0') return false;
  const char * pointer; int n; REMOVE_BLANKS;
  if (n == 0) return false;
  Struct * s = (Struct *)(p);
  return
    ((s->theDictionary).find(string(pointer,n)) == (s->theDictionary).end()) ?
    false : true;
}

References CLHEP::detail::n, G4InuclParticleNames::name(), HepTool::Evaluator::p, REMOVE_BLANKS, and s.

Referenced by G4GDMLEvaluator::DefineConstant(), G4GDMLEvaluator::DefineVariable(), and G4GDMLEvaluator::GetConstant().

print_error() [1/2]

void HepTool::Evaluator::print_error ( ) const

inherited

Prints error message if status() is an ERROR.

Definition at line 643 of file Evaluator.cc.

                                  {
  Struct * s = (Struct *) p;
  if(s->theStatus != OK) {
      std::cerr << error_name() << std::endl;
  }
  return;
}

References HepTool::Evaluator::error_name(), HepTool::Evaluator::OK, HepTool::Evaluator::p, and s.

Referenced by G4GDMLEvaluator::Evaluate(), and print_error().

print_error() [2/2]

void G4tgrEvaluator::print_error

(

G4int

status

)

const

Definition at line 47 of file G4tgrEvaluator.cc.

{
  switch(estatus)
  {
    case ERROR_SYNTAX_ERROR:
      G4cerr << "G4tgrEvaluator: syntax error!" << G4endl;
      return;
    default:
      G4Evaluator::print_error();
      return;
  }
}

References HepTool::Evaluator::ERROR_SYNTAX_ERROR, G4cerr, G4endl, and HepTool::Evaluator::print_error().

Referenced by G4tgrUtils::GetDouble().

removeFunction()

void HepTool::Evaluator::removeFunction ( const char *  name, int  npar  )

inherited

Removes the function from the dictionary.

Parameters

name	name of the function to be unset.
npar	number of parameters of the function.

Definition at line 754 of file Evaluator.cc.

                                                          {
  if (name == 0 || *name == '\0')    return;
  if (npar < 0  || npar > MAX_N_PAR) return;
  const char * pointer; int n; REMOVE_BLANKS;
  if (n == 0) return;
  Struct * s = (Struct *)(p);
  (s->theDictionary).erase(sss[npar]+string(pointer,n));
}

References MAX_N_PAR, CLHEP::detail::n, G4InuclParticleNames::name(), HepTool::Evaluator::p, REMOVE_BLANKS, s, and sss.

removeVariable()

void HepTool::Evaluator::removeVariable ( const char *  name )

inherited

Removes the variable from the dictionary.

Parameters

name	name of the variable.

Definition at line 745 of file Evaluator.cc.

                                                {
  if (name == 0 || *name == '\0') return;
  const char * pointer; int n; REMOVE_BLANKS;
  if (n == 0) return;
  Struct * s = (Struct *)(p);
  (s->theDictionary).erase(string(pointer,n));
}

References CLHEP::detail::n, G4InuclParticleNames::name(), HepTool::Evaluator::p, REMOVE_BLANKS, and s.

setFunction() [1/6]

void HepTool::Evaluator::setFunction ( const char *  name, double(*)()  fun  )

inherited

Adds to the dictionary a function without parameters. If such a function already exist in the dictionary, then status will be set to WARNING_EXISTING_FUNCTION.

Parameters

name	function name.
fun	pointer to the real function in the user code.

Definition at line 698 of file Evaluator.cc.

{ setItem("0", name, Item(reinterpret_cast<voidfuncptr>(fun)), (Struct *)p); }

References G4InuclParticleNames::name(), HepTool::Evaluator::p, and setItem().

Referenced by AddCommonFunctions(), and HepTool::Evaluator::setStdMath().

setFunction() [2/6]

void HepTool::Evaluator::setFunction ( const char *  name, double(*)(double)  fun  )

inherited

Adds to the dictionary a function with one parameter. If such a function already exist in the dictionary, then status will be set to WARNING_EXISTING_FUNCTION.

Parameters

name	function name.
fun	pointer to the real function in the user code.

Definition at line 702 of file Evaluator.cc.

{ setItem("1", name, Item(reinterpret_cast<voidfuncptr>(fun)), (Struct *)p); }

References G4InuclParticleNames::name(), HepTool::Evaluator::p, and setItem().

setFunction() [3/6]

void HepTool::Evaluator::setFunction ( const char *  name, double(*)(double, double)  fun  )

inherited

Adds to the dictionary a function with two parameters. If such a function already exist in the dictionary, then status will be set to WARNING_EXISTING_FUNCTION.

Parameters

name	function name.
fun	pointer to the real function in the user code.

Definition at line 706 of file Evaluator.cc.

{ setItem("2", name, Item(reinterpret_cast<voidfuncptr>(fun)), (Struct *)p); }

References G4InuclParticleNames::name(), HepTool::Evaluator::p, and setItem().

setFunction() [4/6]

void HepTool::Evaluator::setFunction ( const char *  name, double(*)(double, double, double)  fun  )

inherited

Adds to the dictionary a function with three parameters. If such a function already exist in the dictionary, then status will be set to WARNING_EXISTING_FUNCTION.

Parameters

name	function name.
fun	pointer to the real function in the user code.

Definition at line 710 of file Evaluator.cc.

{ setItem("3", name, Item(reinterpret_cast<voidfuncptr>(fun)), (Struct *)p); }

References G4InuclParticleNames::name(), HepTool::Evaluator::p, and setItem().

setFunction() [5/6]

void HepTool::Evaluator::setFunction ( const char *  name, double(*)(double, double, double, double)  fun  )

inherited

Adds to the dictionary a function with four parameters. If such a function already exist in the dictionary, then status will be set to WARNING_EXISTING_FUNCTION.

Parameters

name	function name.
fun	pointer to the real function in the user code.

Definition at line 714 of file Evaluator.cc.

{ setItem("4", name, Item(reinterpret_cast<voidfuncptr>(fun)), (Struct *)p); }

References G4InuclParticleNames::name(), HepTool::Evaluator::p, and setItem().

setFunction() [6/6]

void HepTool::Evaluator::setFunction ( const char *  name, double(*)(double, double, double, double, double)  fun  )

inherited

Adds to the dictionary a function with five parameters. If such a function already exist in the dictionary, then status will be set to WARNING_EXISTING_FUNCTION.

Parameters

name	function name.
fun	pointer to the real function in the user code.

Definition at line 718 of file Evaluator.cc.

{ setItem("5", name, Item(reinterpret_cast<voidfuncptr>(fun)), (Struct *)p); }

References G4InuclParticleNames::name(), HepTool::Evaluator::p, and setItem().

setStdMath()

void HepTool::Evaluator::setStdMath ( )

inherited

Sets standard mathematical functions and constants.

Definition at line 29 of file setStdMath.cc.

                           {
 
  //   S E T   S T A N D A R D   C O N S T A N T S
 
  setVariable("pi",     3.14159265358979323846);
  setVariable("e",      2.7182818284590452354);
  setVariable("gamma",  0.577215664901532861);
  setVariable("radian", 1.0);
  setVariable("rad",    1.0);
  setVariable("degree", 3.14159265358979323846/180.);
  setVariable("deg",    3.14159265358979323846/180.);
 
  //   S E T   S T A N D A R D   F U N C T I O N S
 
  setFunction("abs",   eval_abs);
  setFunction("min",   eval_min);
  setFunction("max",   eval_max);
  setFunction("sqrt",  eval_sqrt);
  setFunction("pow",   eval_pow);
  setFunction("sin",   eval_sin);
  setFunction("cos",   eval_cos);
  setFunction("tan",   eval_tan);
  setFunction("asin",  eval_asin);
  setFunction("acos",  eval_acos);
  setFunction("atan",  eval_atan);
  setFunction("atan2", eval_atan2);
  setFunction("sinh",  eval_sinh);
  setFunction("cosh",  eval_cosh);
  setFunction("tanh",  eval_tanh);
  setFunction("exp",   eval_exp);
  setFunction("log",   eval_log);
  setFunction("log10", eval_log10);
}

References eval_abs(), eval_acos(), eval_asin(), eval_atan(), eval_atan2(), eval_cos(), eval_cosh(), eval_exp(), eval_log(), eval_log10(), eval_max(), eval_min(), eval_pow(), eval_sin(), eval_sinh(), eval_sqrt(), eval_tan(), eval_tanh(), HepTool::Evaluator::setFunction(), and HepTool::Evaluator::setVariable().

Referenced by G4GDMLEvaluator::Clear(), and G4GDMLEvaluator::G4GDMLEvaluator().

setSystemOfUnits()

void HepTool::Evaluator::setSystemOfUnits ( double  meter = 1.0, double  kilogram = 1.0, double  second = 1.0, double  ampere = 1.0, double  kelvin = 1.0, double  mole = 1.0, double  candela = 1.0  )

inherited

Sets system of units. Default is the SI system of units. To set the CGS (Centimeter-Gram-Second) system of units one should call: setSystemOfUnits(100., 1000., 1.0, 1.0, 1.0, 1.0, 1.0);

To set system of units accepted in the GEANT4 simulation toolkit one should call:

setSystemOfUnits(1.e+3, 1./1.60217733e-25, 1.e+9, 1./1.60217733e-10,
                 1.0, 1.0, 1.0);

The basic units in GEANT4 are:

millimeter              (millimeter = 1.)
nanosecond              (nanosecond = 1.)
Mega electron Volt      (MeV        = 1.)
positron charge         (eplus      = 1.)
degree Kelvin           (kelvin     = 1.)
the amount of substance (mole       = 1.)
luminous intensity      (candela    = 1.)
radian                  (radian     = 1.)
steradian               (steradian  = 1.)

Definition at line 8 of file setSystemOfUnits.cc.

{               
  const double kilo_  = 1.e+03; // chilioi (Greek) "thousand"
  const double mega_  = 1.e+06; // megas (Greek) "large"
  const double giga_  = 1.e+09; // gigas (Greek) "giant"
  const double tera_  = 1.e+12; // teras (Greek) "monster"
  const double peta_  = 1.e+15; // pente (Greek) "five"
 
  const double deci_  = 1.e-01; // decimus (Latin) "tenth"
  const double centi_ = 1.e-02; // centum  (Latin) "hundred"
  const double milli_ = 1.e-03; // mille   (Latin) "thousand"
  const double micro_ = 1.e-06; // micro (Latin) or mikros (Greek) "small"
  const double nano_  = 1.e-09; // nanus (Latin) or nanos  (Greek) "dwarf"
  const double pico_  = 1.e-12; // pico (Spanish) "bit"
 
  // ======================================================================
  //
  // Base (default) SI units
  // for the basic measurable quantities (dimensions):
  //
  // ======================================================================
  
  // Length
  // metrum (Latin) and metron (Greek) "measure"
  const double m = meter;
  setVariable("meter", m);
  setVariable("metre", m);
  setVariable("m",     m);
  
  // Mass
  const double kg = kilogram;
  setVariable("kilogram", kg);
  setVariable("kg",       kg);
  
  // Time
  // minuta secundam (Latin) "second small one"
  const double s = second;
  setVariable("second", s);
  setVariable("s",      s);
  
  // Current
  // ---  honors Andre-Marie Ampere (1775-1836) of France
  const double A = ampere;
  setVariable("ampere", A);
  setVariable("amp",    A);
  setVariable("A",      A);
  
  // Temperature
  // ---  honors William Thomson, 1st Baron Lord Kelvin (1824-1907) of England
  const double K = kelvin;
  setVariable("kelvin", K);
  setVariable("K",      K);
  
  // Amount of substance
  const double mol = mole;
  setVariable("mole", mol);
  setVariable("mol",  mol);
  
  // Luminous intensity
  const double cd  = candela;
  setVariable("candela", cd);
  setVariable("cd",      cd);
 
  // ======================================================================
  //
  // Supplementary SI units having special symbols:
  //
  // ======================================================================
 
  // Plane angle 
  const double rad = 1.;
  setVariable("radian", rad);
  setVariable("rad",    rad);
  setVariable("milliradian", milli_ * rad);
  setVariable("mrad",        milli_ * rad);
 
  const double pi  = 3.14159265358979323846;
  const double deg = rad*pi/180.;
  setVariable("degree", deg);
  setVariable("deg",    deg);
 
  // Solid angle
  const double sr  = 1.;
  setVariable("steradian", sr);
  setVariable("sr",        sr);
 
  // ======================================================================
  //
  // Derived SI units having special symbols:
  //
  // ======================================================================
 
  // Frequency
  // ---  honors Heinrich Rudolf Hertz (1857-1894) of Germany
  const double Hz = 1./s;
  setVariable("hertz", Hz);
  setVariable("Hz",    Hz);
 
  // Force
  // ---  honors Sir Isaac Newton (1642-1727) of England
  const double N = m * kg / (s*s);
  setVariable("newton", N);
  setVariable("N",      N);
 
  // Pressure
  // ---  honors Blaise Pascal (1623-1662) of France
  const double Pa = N / (m*m);
  setVariable("pascal", Pa);
  setVariable("Pa",     Pa);
 
  const double atm = 101325. * Pa;
  setVariable("atmosphere", atm);
  setVariable("atm",        atm);
 
  const double bar = 100000*Pa;
  setVariable("bar", bar);
 
  // Energy
  // ---  honors James Prescott Joule (1818-1889) of England
  const double J = N * m;
  setVariable("joule", J);
  setVariable("J",     J);
 
  // Power
  // ---  honors James Watt (1736-1819) of Scotland
  const double W = J / s;
  setVariable("watt", W);
  setVariable("W",    W);
 
  // Electric charge
  // ---  honors Charles-Augustin de Coulomb (1736-1806) of France
  const double C = A * s;
  setVariable("coulomb", C);
  setVariable("C",       C);
 
  // Electric potential  
  // ---  honors Count Alessandro Volta (1745-1827) of Italy
  const double V = J / C;
  setVariable("volt", V);
  setVariable("V",    V);
 
  // Electric resistance
  // ---  honors Georg Simon Ohm (1787-1854) of Germany
  const double ohm = V / A;
  setVariable("ohm", ohm);
 
  // Electric conductance
  // ---  honors Ernst Werner von Siemens (1816-1892) or
  //      his brother Sir William (Karl Wilhelm von) Siemens (1823-1883)
  //      of Germany (England)
  const double S = 1./ ohm;
  setVariable("siemens", S);
  setVariable("S",       S);
 
  // Electric capacitance
  // ---  honors Michael Faraday (1791-1867) of England
  const double F = C / V;
  setVariable("farad", F);
  setVariable("F",     F);
 
  // Magnetic flux density
  // ---  honors Nikola Tesla (1856-1943) of Croatia (United States)
  const double T = V * s / (m*m);
  setVariable("tesla", T);
  setVariable("T",     T);
 
  // ---  honors Karl Friedrich Gauss (1777-1855) of Germany
  const double Gs = 1.e-4*T;
  setVariable("gauss", Gs);
  setVariable("Gs",    Gs);
 
  // Magnetic flux
  // ---  honors Wilhelm Eduard Weber (1804-1891) of Germany
  const double Wb = V * s;
  setVariable("weber", Wb);
  setVariable("Wb",    Wb);
 
  // Inductance
  // ---  honors Joseph Henry (1797-1878) of the United States
  const double H = Wb / A;
  setVariable("henry", H);
  setVariable("H",     H);
 
  // Luminous flux
  const double lm = cd * sr;
  setVariable("lumen", lm);
  setVariable("lm",    lm);
 
  // Illuminace
  const double lx = lm / (m*m);
  setVariable("lux", lx);
  setVariable("lx",  lx);
 
  // Radioactivity
  // ---  honors Antoine-Henri Becquerel (1852-1908) of France
  const double Bq = 1./s;
  setVariable("becquerel", Bq);
  setVariable("Bq",        Bq);
  setVariable("kilobecquerel",  kilo_ * Bq);
  setVariable("kBq",            kilo_ * Bq);
  setVariable("megabecquerel",  mega_ * Bq);
  setVariable("MBq",            mega_ * Bq);
  setVariable("gigabecquerel",  giga_ * Bq);
  setVariable("GBq",            giga_ * Bq);
 
  // ---  honors Pierre Curie (1859-1906) of France
  //      and Marie Sklodowska Curie (1867-1934) of Poland
  setVariable("curie", 3.7e+10 * Bq);
  setVariable("Ci",    3.7e+10 * Bq);
  setVariable("millicurie", milli_ * 3.7e+10 * Bq);
  setVariable("mCi",        milli_ * 3.7e+10 * Bq);
  setVariable("microcurie", micro_ * 3.7e+10 * Bq);
  setVariable("uCi",        micro_ * 3.7e+10 * Bq);
 
  // Specific energy
  // ---  honors Louis Harold Gray, F.R.S. (1905-1965) of England
  const double Gy = J / kg;
  setVariable("gray", Gy);
  setVariable("Gy",   Gy);
  setVariable("kilogray",   kilo_ * Gy);
  setVariable("milligray", milli_ * Gy);
  setVariable("microgray", micro_ * Gy);
 
  // Dose equivalent
  const double Sv = J / kg;
  setVariable("sievert", Sv);
  setVariable("Sv",      Sv);
 
  // ======================================================================
  //
  // Selected units:
  //
  // ======================================================================
 
  // Length
 
  const double mm = milli_ * m;
  setVariable("millimeter", mm);
  setVariable("mm",         mm);
 
  const double cm = centi_ * m;
  setVariable("centimeter", cm);
  setVariable("cm",         cm);
 
  setVariable("decimeter",  deci_ * m);
 
  const double km = kilo_ * m; 
  setVariable("kilometer",  km);
  setVariable("km",         km);
 
  setVariable("micrometer", micro_ * m);
  setVariable("micron",     micro_ * m);
  setVariable("nanometer",  nano_  * m);
 
  // ---  honors Anders Jonas Angstrom (1814-1874) of Sweden
  setVariable("angstrom",   1.e-10 * m);
 
  // ---  honors Enrico Fermi (1901-1954) of Italy
  setVariable("fermi",      1.e-15 * m);
 
  // Length^2
 
  setVariable("m2",  m*m);
  setVariable("mm2", mm*mm);
  setVariable("cm2", cm*cm);
  setVariable("km2", km*km);
 
  const double barn = 1.e-28 * m*m; 
  setVariable("barn",      barn);
  setVariable("millibarn", milli_ * barn);
  setVariable("mbarn",     milli_ * barn);
  setVariable("microbarn", micro_ * barn);
  setVariable("nanobarn",  nano_  * barn);
  setVariable("picobarn",  pico_  * barn);
 
  // LengthL^3
 
  setVariable("m3",  m*m*m);
  setVariable("mm3", mm*mm*mm);
  setVariable("cm3", cm*cm*cm);
  setVariable("cc",  cm*cm*cm);
  setVariable("km3", km*km*km);
 
  const double L = 1.e-3*m*m*m;
  setVariable("liter", L);  
  setVariable("litre", L);  
  setVariable("L",     L);  
  setVariable("centiliter",  centi_ * L);
  setVariable("cL",          centi_ * L);
  setVariable("milliliter",  milli_ * L);
  setVariable("mL",          milli_ * L);
 
  // Length^-1
 
  const double dpt = 1./m;
  setVariable("diopter", dpt);
  setVariable("dioptre", dpt);
  setVariable("dpt",     dpt);
 
  // Mass
 
  const double g = 0.001*kg;
  setVariable("gram", g);
  setVariable("g",    g);
  setVariable("milligram",   milli_ * g);
  setVariable("mg",          milli_ * g);
  
  // Time
 
  setVariable("millisecond", milli_ * s);
  setVariable("ms",          milli_ * s);
  setVariable("microsecond", micro_ * s);
  setVariable("us",          micro_ * s);
  setVariable("nanosecond",  nano_  * s);
  setVariable("ns",          nano_  * s);
  setVariable("picosecond",  pico_  * s);
  setVariable("ps",          pico_  * s);
 
  // Current
 
  setVariable("milliampere", milli_ * A);
  setVariable("mA",          milli_ * A);
  setVariable("microampere", micro_ * A);
  setVariable("nanoampere",  nano_  * A);
 
  // Frequency
 
  setVariable("kilohertz",   kilo_ * Hz);
  setVariable("kHz",         kilo_ * Hz);
  setVariable("megahertz",   mega_ * Hz);
  setVariable("MHz",         mega_ * Hz);
 
  // Force
  setVariable("kilonewton",  kilo_ * N);
  setVariable("kN",          kilo_ * N);
 
  // Pressure
  setVariable("kilobar",     kilo_ * bar);
  setVariable("kbar",        kilo_ * bar);
  setVariable("millibar",    milli_ * bar);
  setVariable("mbar",        milli_ * bar);
 
  // Energy
  setVariable("kilojoule",   kilo_ * J);
  setVariable("kJ",          kilo_ * J);
  setVariable("megajoule",   mega_ * J);
  setVariable("MJ",          mega_ * J);
  setVariable("gigajoule",   giga_ * J);
  setVariable("GJ",          giga_ * J);
 
  const double e_SI  = 1.60217733e-19;  // positron charge in coulomb
  const double ePlus = e_SI * C;        // positron charge
  const double eV    = ePlus * V;
  setVariable("electronvolt", eV);
  setVariable("eV",           eV);
  setVariable("kiloelectronvolt", kilo_ * eV);
  setVariable("keV",              kilo_ * eV);
  setVariable("megaelectronvolt", mega_ * eV);
  setVariable("MeV",              mega_ * eV);
  setVariable("gigaelectronvolt", giga_ * eV);
  setVariable("GeV",              giga_ * eV);
  setVariable("teraelectronvolt", tera_ * eV);
  setVariable("TeV",              tera_ * eV);
  setVariable("petaelectronvolt", peta_ * eV);
  setVariable("PeV",              peta_ * eV);
 
  // Power
  setVariable("kilowatt",    kilo_ * W);
  setVariable("kW",          kilo_ * W);
  setVariable("megawatt",    mega_ * W);
  setVariable("MW",          mega_ * W);
  setVariable("gigawatt",    giga_ * W);
  setVariable("GW",          giga_ * W);
 
  // Electric potential  
  setVariable("kilovolt",    kilo_ * V);
  setVariable("kV",          kilo_ * V);
  setVariable("megavolt",    mega_ * V);
  setVariable("MV",          mega_ * V);
 
  // Electric capacitance
  setVariable("millifarad",  milli_ * F);
  setVariable("mF",          milli_ * F);
  setVariable("microfarad",  micro_ * F);
  setVariable("uF",          micro_ * F);
  setVariable("nanofarad",   nano_  * F);
  setVariable("nF",          nano_  * F);
  setVariable("picofarad",   pico_  * F);
  setVariable("pF",          pico_  * F);
 
  // Magnetic flux density
  setVariable("kilogauss",   kilo_ * Gs);
  setVariable("kGs",         kilo_ * Gs);
}

References A, ampere, bar, barn, Bq, C(), candela, cd, cm, deg, e_SI, eV, g, kelvin, kg, kilogram, km, L, m, meter, mm, mole, ohm, pi, rad, s, S(), second, HepTool::Evaluator::setVariable(), and sr.

Referenced by G4GDMLEvaluator::Clear(), and G4GDMLEvaluator::G4GDMLEvaluator().

setVariable() [1/2]

void HepTool::Evaluator::setVariable ( const char *  name, const char *  expression  )

inherited

Adds to the dictionary a variable with an arithmetic expression assigned to it. If a variable with such a name already exist in the dictionary, then status will be set to WARNING_EXISTING_VARIABLE.

Parameters

name	name of the variable.
expression	arithmetic expression.

Definition at line 692 of file Evaluator.cc.

{ setItem("", name, Item(expression), (Struct *)p); }

References G4InuclParticleNames::name(), HepTool::Evaluator::p, and setItem().

setVariable() [2/2]

void HepTool::Evaluator::setVariable ( const char *  name, double  value  )

inherited

Adds to the dictionary a variable with given value. If a variable with such a name already exist in the dictionary, then status will be set to WARNING_EXISTING_VARIABLE.

Parameters

name	name of the variable.
value	value assigned to the variable.

Definition at line 689 of file Evaluator.cc.

{ setItem("", name, Item(value), (Struct *)p); }

References G4InuclParticleNames::name(), HepTool::Evaluator::p, and setItem().

Referenced by G4GDMLEvaluator::DefineConstant(), G4GDMLEvaluator::DefineVariable(), HepTool::Evaluator::setStdMath(), HepTool::Evaluator::setSystemOfUnits(), and G4GDMLEvaluator::SetVariable().

status()

int HepTool::Evaluator::status ( ) const

inherited

Returns status of the last operation with the evaluator.

Definition at line 633 of file Evaluator.cc.

                            {
  return ((Struct *)(p))->theStatus;
}

References HepTool::Evaluator::p.

Referenced by G4GDMLEvaluator::Evaluate(), and G4tgrUtils::GetDouble().

Field Documentation

p

void* HepTool::Evaluator::p

privateinherited

Definition at line 256 of file Evaluator.h.

Referenced by HepTool::Evaluator::clear(), HepTool::Evaluator::error_name(), HepTool::Evaluator::error_position(), HepTool::Evaluator::evaluate(), HepTool::Evaluator::Evaluator(), HepTool::Evaluator::findFunction(), HepTool::Evaluator::findVariable(), HepTool::Evaluator::print_error(), HepTool::Evaluator::removeFunction(), HepTool::Evaluator::removeVariable(), HepTool::Evaluator::setFunction(), HepTool::Evaluator::setVariable(), HepTool::Evaluator::status(), and HepTool::Evaluator::~Evaluator().

---

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

• source/persistency/ascii/include/G4tgrEvaluator.hh
• source/persistency/ascii/src/G4tgrEvaluator.cc