Geant4  10.03.p01
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
HepTool::Evaluator Class Reference

#include <Evaluator.h>

Inheritance diagram for HepTool::Evaluator:

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

 Evaluator ()
 
 ~Evaluator ()
 
double evaluate (const char *expression)
 
int status () const
 
int error_position () const
 
void print_error () const
 
std::string error_name () const
 
void setVariable (const char *name, double value)
 
void setVariable (const char *name, const char *expression)
 
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))
 
bool findVariable (const char *name) const
 
bool findFunction (const char *name, int npar) const
 
void removeVariable (const char *name)
 
void removeFunction (const char *name, int npar)
 
void clear ()
 
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)
 

Detailed Description

Evaluator of arithmetic expressions with an extendable dictionary. Example:

* #include "CLHEP/Evaluator/Evaluator.h"
* eval.setStdMath();
* double res = eval.evaluate("sin(30*degree)");
* if (eval.status() != HepTool::Evaluator::OK) eval.print_error();
*
Author
Evgeni Chernyaev Evgue.nosp@m.ni.T.nosp@m.chern.nosp@m.iaev.nosp@m.@cern.nosp@m..ch

Definition at line 26 of file Evaluator.h.

Member Enumeration Documentation

anonymous enum

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 39 of file Evaluator.h.

Constructor & Destructor Documentation

HepTool::Evaluator::Evaluator ( )

Constructor.

Definition at line 596 of file Evaluator.cc.

596  {
597  Struct * s = new Struct();
598  p = (void *) s;
599  s->theExpression = 0;
600  s->thePosition = 0;
601  s->theStatus = OK;
602  s->theResult = 0.0;
603 }
const char * p
Definition: xmltok.h:285
pchar thePosition
Definition: Evaluator.cc:43
const XML_Char * s
Definition: expat.h:262
double theResult
Definition: Evaluator.cc:45
pchar theExpression
Definition: Evaluator.cc:42
int theStatus
Definition: Evaluator.cc:44
HepTool::Evaluator::~Evaluator ( )

Destructor.

Definition at line 606 of file Evaluator.cc.

606  {
607  delete (Struct *)(p);
608 }
const char * p
Definition: xmltok.h:285

Member Function Documentation

void HepTool::Evaluator::clear ( )

Clear all settings.

Definition at line 762 of file Evaluator.cc.

762  {
763  Struct * s = (Struct *) p;
764  s->theDictionary.clear();
765  s->theExpression = 0;
766  s->thePosition = 0;
767  s->theStatus = OK;
768  s->theResult = 0.0;
769 }
const char * p
Definition: xmltok.h:285
pchar thePosition
Definition: Evaluator.cc:43
const XML_Char * s
Definition: expat.h:262
dic_type theDictionary
Definition: Evaluator.cc:41
double theResult
Definition: Evaluator.cc:45
pchar theExpression
Definition: Evaluator.cc:42
int theStatus
Definition: Evaluator.cc:44

Here is the caller graph for this function:

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

get a string defining the error name

Definition at line 650 of file Evaluator.cc.

651 {
652  char prefix[] = "Evaluator : ";
653  std::ostringstream errn;
654  Struct * s = (Struct *) p;
655  switch (s->theStatus) {
656  case ERROR_NOT_A_NAME:
657  errn << prefix << "invalid name";
658  break;
659  case ERROR_SYNTAX_ERROR:
660  errn << prefix << "syntax error";
661  break;
663  errn << prefix << "unpaired parenthesis";
664  break;
666  errn << prefix << "unexpected symbol";
667  break;
669  errn << prefix << "unknown variable";
670  break;
672  errn << prefix << "unknown function";
673  break;
674  case ERROR_EMPTY_PARAMETER:
675  errn << prefix << "empty parameter in function call";
676  break;
678  errn << prefix << "calculation error";
679  break;
680  default:
681  errn << " ";
682  }
683  return errn.str();
684 }
const char * p
Definition: xmltok.h:285
const XML_Char * s
Definition: expat.h:262
int theStatus
Definition: Evaluator.cc:44

Here is the caller graph for this function:

int HepTool::Evaluator::error_position ( ) const

Returns position in the input string where the problem occured.

Definition at line 636 of file Evaluator.cc.

636  {
637  return ((Struct *)(p))->thePosition - ((Struct *)(p))->theExpression;
638 }
const char * p
Definition: xmltok.h:285
double HepTool::Evaluator::evaluate ( const char *  expression)

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

Parameters
expressioninput expression.
Returns
result of the evaluation.
See Also
status
error_position
print_error

Definition at line 611 of file Evaluator.cc.

611  {
612  Struct * s = (Struct *)(p);
613  if (s->theExpression != 0) { delete[] s->theExpression; }
614  s->theExpression = 0;
615  s->thePosition = 0;
617  s->theResult = 0.0;
618  if (expression != 0) {
619  s->theExpression = new char[strlen(expression)+1];
620  strcpy(s->theExpression, expression);
622  s->theExpression+strlen(expression)-1,
623  s->theResult,
624  s->thePosition,
625  s->theDictionary);
626  }
627  return s->theResult;
628 }
const char * p
Definition: xmltok.h:285
pchar thePosition
Definition: Evaluator.cc:43
static int engine(pchar, pchar, double &, pchar &, const dic_type &)
Definition: Evaluator.cc:358
const XML_Char * s
Definition: expat.h:262
dic_type theDictionary
Definition: Evaluator.cc:41
double theResult
Definition: Evaluator.cc:45
pchar theExpression
Definition: Evaluator.cc:42
int theStatus
Definition: Evaluator.cc:44

Here is the call graph for this function:

Here is the caller graph for this function:

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

Finds the function in the dictionary.

Parameters
namename of the function to be unset.
nparnumber of parameters of the function.
Returns
true if such a function exists, false otherwise.

Definition at line 732 of file Evaluator.cc.

732  {
733  if (name == 0 || *name == '\0') return false;
734  if (npar < 0 || npar > MAX_N_PAR) return false;
735  const char * pointer; int n; REMOVE_BLANKS;
736  if (n == 0) return false;
737  Struct * s = (Struct *)(p);
738  return ((s->theDictionary).find(sss[npar]+string(pointer,n)) ==
739  (s->theDictionary).end()) ? false : true;
740 }
const XML_Char * name
Definition: expat.h:151
#define REMOVE_BLANKS
Definition: Evaluator.cc:51
const char * p
Definition: xmltok.h:285
const XML_Char * s
Definition: expat.h:262
dic_type theDictionary
Definition: Evaluator.cc:41
#define MAX_N_PAR
Definition: Evaluator.cc:62
static const char sss[MAX_N_PAR+2]
Definition: Evaluator.cc:64
bool HepTool::Evaluator::findVariable ( const char *  name) const

Finds the variable in the dictionary.

Parameters
namename of the variable.
Returns
true if such a variable exists, false otherwise.

Definition at line 721 of file Evaluator.cc.

721  {
722  if (name == 0 || *name == '\0') return false;
723  const char * pointer; int n; REMOVE_BLANKS;
724  if (n == 0) return false;
725  Struct * s = (Struct *)(p);
726  return
727  ((s->theDictionary).find(string(pointer,n)) == (s->theDictionary).end()) ?
728  false : true;
729 }
const XML_Char * name
Definition: expat.h:151
#define REMOVE_BLANKS
Definition: Evaluator.cc:51
const char * p
Definition: xmltok.h:285
const XML_Char * s
Definition: expat.h:262
dic_type theDictionary
Definition: Evaluator.cc:41

Here is the caller graph for this function:

void HepTool::Evaluator::print_error ( ) const

Prints error message if status() is an ERROR.

Definition at line 641 of file Evaluator.cc.

641  {
642  Struct * s = (Struct *) p;
643  if(s->theStatus != OK) {
644  std::cerr << error_name() << std::endl;
645  }
646  return;
647 }
const char * p
Definition: xmltok.h:285
const XML_Char * s
Definition: expat.h:262
std::string error_name() const
Definition: Evaluator.cc:650
int theStatus
Definition: Evaluator.cc:44

Here is the call graph for this function:

Here is the caller graph for this function:

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

Removes the function from the dictionary.

Parameters
namename of the function to be unset.
nparnumber of parameters of the function.

Definition at line 752 of file Evaluator.cc.

752  {
753  if (name == 0 || *name == '\0') return;
754  if (npar < 0 || npar > MAX_N_PAR) return;
755  const char * pointer; int n; REMOVE_BLANKS;
756  if (n == 0) return;
757  Struct * s = (Struct *)(p);
758  (s->theDictionary).erase(sss[npar]+string(pointer,n));
759 }
const XML_Char * name
Definition: expat.h:151
#define REMOVE_BLANKS
Definition: Evaluator.cc:51
const char * p
Definition: xmltok.h:285
const XML_Char * s
Definition: expat.h:262
dic_type theDictionary
Definition: Evaluator.cc:41
#define MAX_N_PAR
Definition: Evaluator.cc:62
static const char sss[MAX_N_PAR+2]
Definition: Evaluator.cc:64
void HepTool::Evaluator::removeVariable ( const char *  name)

Removes the variable from the dictionary.

Parameters
namename of the variable.

Definition at line 743 of file Evaluator.cc.

743  {
744  if (name == 0 || *name == '\0') return;
745  const char * pointer; int n; REMOVE_BLANKS;
746  if (n == 0) return;
747  Struct * s = (Struct *)(p);
748  (s->theDictionary).erase(string(pointer,n));
749 }
const XML_Char * name
Definition: expat.h:151
#define REMOVE_BLANKS
Definition: Evaluator.cc:51
const char * p
Definition: xmltok.h:285
const XML_Char * s
Definition: expat.h:262
dic_type theDictionary
Definition: Evaluator.cc:41
void HepTool::Evaluator::setFunction ( const char *  name,
double(*)()  fun 
)

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
namefunction name.
funpointer to the real function in the user code.

Definition at line 696 of file Evaluator.cc.

698 { setItem("0", name, Item(reinterpret_cast<voidfuncptr>(fun)), (Struct *)p); }
const XML_Char * name
Definition: expat.h:151
const char * p
Definition: xmltok.h:285
static void setItem(const char *prefix, const char *name, const Item &item, Struct *s)
Definition: Evaluator.cc:549

Here is the call graph for this function:

Here is the caller graph for this function:

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

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
namefunction name.
funpointer to the real function in the user code.

Definition at line 700 of file Evaluator.cc.

702 { setItem("1", name, Item(reinterpret_cast<voidfuncptr>(fun)), (Struct *)p); }
const XML_Char * name
Definition: expat.h:151
const char * p
Definition: xmltok.h:285
static void setItem(const char *prefix, const char *name, const Item &item, Struct *s)
Definition: Evaluator.cc:549

Here is the call graph for this function:

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

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
namefunction name.
funpointer to the real function in the user code.

Definition at line 704 of file Evaluator.cc.

706 { setItem("2", name, Item(reinterpret_cast<voidfuncptr>(fun)), (Struct *)p); }
const XML_Char * name
Definition: expat.h:151
const char * p
Definition: xmltok.h:285
static void setItem(const char *prefix, const char *name, const Item &item, Struct *s)
Definition: Evaluator.cc:549

Here is the call graph for this function:

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

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
namefunction name.
funpointer to the real function in the user code.

Definition at line 708 of file Evaluator.cc.

710 { setItem("3", name, Item(reinterpret_cast<voidfuncptr>(fun)), (Struct *)p); }
const XML_Char * name
Definition: expat.h:151
const char * p
Definition: xmltok.h:285
static void setItem(const char *prefix, const char *name, const Item &item, Struct *s)
Definition: Evaluator.cc:549

Here is the call graph for this function:

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

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
namefunction name.
funpointer to the real function in the user code.

Definition at line 712 of file Evaluator.cc.

714 { setItem("4", name, Item(reinterpret_cast<voidfuncptr>(fun)), (Struct *)p); }
const XML_Char * name
Definition: expat.h:151
const char * p
Definition: xmltok.h:285
static void setItem(const char *prefix, const char *name, const Item &item, Struct *s)
Definition: Evaluator.cc:549

Here is the call graph for this function:

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

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
namefunction name.
funpointer to the real function in the user code.

Definition at line 716 of file Evaluator.cc.

718 { setItem("5", name, Item(reinterpret_cast<voidfuncptr>(fun)), (Struct *)p); }
const XML_Char * name
Definition: expat.h:151
const char * p
Definition: xmltok.h:285
static void setItem(const char *prefix, const char *name, const Item &item, Struct *s)
Definition: Evaluator.cc:549

Here is the call graph for this function:

void HepTool::Evaluator::setStdMath ( )

Sets standard mathematical functions and constants.

Definition at line 30 of file setStdMath.cc.

30  {
31 
32  // S E T S T A N D A R D C O N S T A N T S
33 
34  setVariable("pi", 3.14159265358979323846);
35  setVariable("e", 2.7182818284590452354);
36  setVariable("gamma", 0.577215664901532861);
37  setVariable("radian", 1.0);
38  setVariable("rad", 1.0);
39  setVariable("degree", 3.14159265358979323846/180.);
40  setVariable("deg", 3.14159265358979323846/180.);
41 
42  // S E T S T A N D A R D F U N C T I O N S
43 
44  setFunction("abs", eval_abs);
45  setFunction("min", eval_min);
46  setFunction("max", eval_max);
47  setFunction("sqrt", eval_sqrt);
48  setFunction("pow", eval_pow);
49  setFunction("sin", eval_sin);
50  setFunction("cos", eval_cos);
51  setFunction("tan", eval_tan);
52  setFunction("asin", eval_asin);
53  setFunction("acos", eval_acos);
54  setFunction("atan", eval_atan);
55  setFunction("atan2", eval_atan2);
56  setFunction("sinh", eval_sinh);
57  setFunction("cosh", eval_cosh);
58  setFunction("tanh", eval_tanh);
59  setFunction("exp", eval_exp);
60  setFunction("log", eval_log);
61  setFunction("log10", eval_log10);
62 }
static double eval_min(double a, double b)
Definition: setStdMath.cc:10
static double eval_pow(double a, double b)
Definition: setStdMath.cc:13
static double eval_acos(double a)
Definition: setStdMath.cc:18
static double eval_sin(double a)
Definition: setStdMath.cc:14
static double eval_asin(double a)
Definition: setStdMath.cc:17
void setFunction(const char *name, double(*fun)())
Definition: Evaluator.cc:696
static double eval_exp(double a)
Definition: setStdMath.cc:24
static double eval_abs(double a)
Definition: setStdMath.cc:9
static double eval_max(double a, double b)
Definition: setStdMath.cc:11
static double eval_sqrt(double a)
Definition: setStdMath.cc:12
static double eval_atan(double a)
Definition: setStdMath.cc:19
static double eval_tanh(double a)
Definition: setStdMath.cc:23
void setVariable(const char *name, double value)
Definition: Evaluator.cc:687
static double eval_atan2(double a, double b)
Definition: setStdMath.cc:20
static double eval_sinh(double a)
Definition: setStdMath.cc:21
static double eval_log(double a)
Definition: setStdMath.cc:25
static double eval_cos(double a)
Definition: setStdMath.cc:15
static double eval_cosh(double a)
Definition: setStdMath.cc:22
static double eval_log10(double a)
Definition: setStdMath.cc:26
static double eval_tan(double a)
Definition: setStdMath.cc:16

Here is the call graph for this function:

Here is the caller graph for this function:

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 
)

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:

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

Definition at line 9 of file setSystemOfUnits.cc.

16 {
17  const double kilo_ = 1.e+03; // chilioi (Greek) "thousand"
18  const double mega_ = 1.e+06; // megas (Greek) "large"
19  const double giga_ = 1.e+09; // gigas (Greek) "giant"
20  const double tera_ = 1.e+12; // teras (Greek) "monster"
21  const double peta_ = 1.e+15; // pente (Greek) "five"
22 
23  const double deci_ = 1.e-01; // decimus (Latin) "tenth"
24  const double centi_ = 1.e-02; // centum (Latin) "hundred"
25  const double milli_ = 1.e-03; // mille (Latin) "thousand"
26  const double micro_ = 1.e-06; // micro (Latin) or mikros (Greek) "small"
27  const double nano_ = 1.e-09; // nanus (Latin) or nanos (Greek) "dwarf"
28  const double pico_ = 1.e-12; // pico (Spanish) "bit"
29 
30  // ======================================================================
31  //
32  // Base (default) SI units
33  // for the basic measurable quantities (dimensions):
34  //
35  // ======================================================================
36 
37  // Length
38  // metrum (Latin) and metron (Greek) "measure"
39  const double m = meter;
40  setVariable("meter", m);
41  setVariable("metre", m);
42  setVariable("m", m);
43 
44  // Mass
45  const double kg = kilogram;
46  setVariable("kilogram", kg);
47  setVariable("kg", kg);
48 
49  // Time
50  // minuta secundam (Latin) "second small one"
51  const double s = second;
52  setVariable("second", s);
53  setVariable("s", s);
54 
55  // Current
56  // --- honors Andre-Marie Ampere (1775-1836) of France
57  const double A = ampere;
58  setVariable("ampere", A);
59  setVariable("amp", A);
60  setVariable("A", A);
61 
62  // Temperature
63  // --- honors William Thomson, 1st Baron Lord Kelvin (1824-1907) of England
64  const double K = kelvin;
65  setVariable("kelvin", K);
66  setVariable("K", K);
67 
68  // Amount of substance
69  const double mol = mole;
70  setVariable("mole", mol);
71  setVariable("mol", mol);
72 
73  // Luminous intensity
74  const double cd = candela;
75  setVariable("candela", cd);
76  setVariable("cd", cd);
77 
78  // ======================================================================
79  //
80  // Supplementary SI units having special symbols:
81  //
82  // ======================================================================
83 
84  // Plane angle
85  const double rad = 1.;
86  setVariable("radian", rad);
87  setVariable("rad", rad);
88  setVariable("milliradian", milli_ * rad);
89  setVariable("mrad", milli_ * rad);
90 
91  const double pi = 3.14159265358979323846;
92  const double deg = rad*pi/180.;
93  setVariable("degree", deg);
94  setVariable("deg", deg);
95 
96  // Solid angle
97  const double sr = 1.;
98  setVariable("steradian", sr);
99  setVariable("sr", sr);
100 
101  // ======================================================================
102  //
103  // Derived SI units having special symbols:
104  //
105  // ======================================================================
106 
107  // Frequency
108  // --- honors Heinrich Rudolf Hertz (1857-1894) of Germany
109  const double Hz = 1./s;
110  setVariable("hertz", Hz);
111  setVariable("Hz", Hz);
112 
113  // Force
114  // --- honors Sir Isaac Newton (1642-1727) of England
115  const double N = m * kg / (s*s);
116  setVariable("newton", N);
117  setVariable("N", N);
118 
119  // Pressure
120  // --- honors Blaise Pascal (1623-1662) of France
121  const double Pa = N / (m*m);
122  setVariable("pascal", Pa);
123  setVariable("Pa", Pa);
124 
125  const double atm = 101325. * Pa;
126  setVariable("atmosphere", atm);
127  setVariable("atm", atm);
128 
129  const double bar = 100000*Pa;
130  setVariable("bar", bar);
131 
132  // Energy
133  // --- honors James Prescott Joule (1818-1889) of England
134  const double J = N * m;
135  setVariable("joule", J);
136  setVariable("J", J);
137 
138  // Power
139  // --- honors James Watt (1736-1819) of Scotland
140  const double W = J / s;
141  setVariable("watt", W);
142  setVariable("W", W);
143 
144  // Electric charge
145  // --- honors Charles-Augustin de Coulomb (1736-1806) of France
146  const double C = A * s;
147  setVariable("coulomb", C);
148  setVariable("C", C);
149 
150  // Electric potential
151  // --- honors Count Alessandro Volta (1745-1827) of Italy
152  const double V = J / C;
153  setVariable("volt", V);
154  setVariable("V", V);
155 
156  // Electric resistance
157  // --- honors Georg Simon Ohm (1787-1854) of Germany
158  const double ohm = V / A;
159  setVariable("ohm", ohm);
160 
161  // Electric conductance
162  // --- honors Ernst Werner von Siemens (1816-1892) or
163  // his brother Sir William (Karl Wilhelm von) Siemens (1823-1883)
164  // of Germany (England)
165  const double S = 1./ ohm;
166  setVariable("siemens", S);
167  setVariable("S", S);
168 
169  // Electric capacitance
170  // --- honors Michael Faraday (1791-1867) of England
171  const double F = C / V;
172  setVariable("farad", F);
173  setVariable("F", F);
174 
175  // Magnetic flux density
176  // --- honors Nikola Tesla (1856-1943) of Croatia (United States)
177  const double T = V * s / (m*m);
178  setVariable("tesla", T);
179  setVariable("T", T);
180 
181  // --- honors Karl Friedrich Gauss (1777-1855) of Germany
182  const double Gs = 1.e-4*T;
183  setVariable("gauss", Gs);
184  setVariable("Gs", Gs);
185 
186  // Magnetic flux
187  // --- honors Wilhelm Eduard Weber (1804-1891) of Germany
188  const double Wb = V * s;
189  setVariable("weber", Wb);
190  setVariable("Wb", Wb);
191 
192  // Inductance
193  // --- honors Joseph Henry (1797-1878) of the United States
194  const double H = Wb / A;
195  setVariable("henry", H);
196  setVariable("H", H);
197 
198  // Luminous flux
199  const double lm = cd * sr;
200  setVariable("lumen", lm);
201  setVariable("lm", lm);
202 
203  // Illuminace
204  const double lx = lm / (m*m);
205  setVariable("lux", lx);
206  setVariable("lx", lx);
207 
208  // Radioactivity
209  // --- honors Antoine-Henri Becquerel (1852-1908) of France
210  const double Bq = 1./s;
211  setVariable("becquerel", Bq);
212  setVariable("Bq", Bq);
213  setVariable("kilobecquerel", kilo_ * Bq);
214  setVariable("kBq", kilo_ * Bq);
215  setVariable("megabecquerel", mega_ * Bq);
216  setVariable("MBq", mega_ * Bq);
217  setVariable("gigabecquerel", giga_ * Bq);
218  setVariable("GBq", giga_ * Bq);
219 
220  // --- honors Pierre Curie (1859-1906) of France
221  // and Marie Sklodowska Curie (1867-1934) of Poland
222  setVariable("curie", 3.7e+10 * Bq);
223  setVariable("Ci", 3.7e+10 * Bq);
224  setVariable("millicurie", milli_ * 3.7e+10 * Bq);
225  setVariable("mCi", milli_ * 3.7e+10 * Bq);
226  setVariable("microcurie", micro_ * 3.7e+10 * Bq);
227  setVariable("uCi", micro_ * 3.7e+10 * Bq);
228 
229  // Specific energy
230  // --- honors Louis Harold Gray, F.R.S. (1905-1965) of England
231  const double Gy = J / kg;
232  setVariable("gray", Gy);
233  setVariable("Gy", Gy);
234  setVariable("kilogray", kilo_ * Gy);
235  setVariable("milligray", milli_ * Gy);
236  setVariable("microgray", micro_ * Gy);
237 
238  // Dose equivalent
239  const double Sv = J / kg;
240  setVariable("sievert", Sv);
241  setVariable("Sv", Sv);
242 
243  // ======================================================================
244  //
245  // Selected units:
246  //
247  // ======================================================================
248 
249  // Length
250 
251  const double mm = milli_ * m;
252  setVariable("millimeter", mm);
253  setVariable("mm", mm);
254 
255  const double cm = centi_ * m;
256  setVariable("centimeter", cm);
257  setVariable("cm", cm);
258 
259  setVariable("decimeter", deci_ * m);
260 
261  const double km = kilo_ * m;
262  setVariable("kilometer", km);
263  setVariable("km", km);
264 
265  setVariable("micrometer", micro_ * m);
266  setVariable("micron", micro_ * m);
267  setVariable("nanometer", nano_ * m);
268 
269  // --- honors Anders Jonas Angstrom (1814-1874) of Sweden
270  setVariable("angstrom", 1.e-10 * m);
271 
272  // --- honors Enrico Fermi (1901-1954) of Italy
273  setVariable("fermi", 1.e-15 * m);
274 
275  // Length^2
276 
277  setVariable("m2", m*m);
278  setVariable("mm2", mm*mm);
279  setVariable("cm2", cm*cm);
280  setVariable("km2", km*km);
281 
282  const double barn = 1.e-28 * m*m;
283  setVariable("barn", barn);
284  setVariable("millibarn", milli_ * barn);
285  setVariable("mbarn", milli_ * barn);
286  setVariable("microbarn", micro_ * barn);
287  setVariable("nanobarn", nano_ * barn);
288  setVariable("picobarn", pico_ * barn);
289 
290  // LengthL^3
291 
292  setVariable("m3", m*m*m);
293  setVariable("mm3", mm*mm*mm);
294  setVariable("cm3", cm*cm*cm);
295  setVariable("cc", cm*cm*cm);
296  setVariable("km3", km*km*km);
297 
298  const double L = 1.e-3*m*m*m;
299  setVariable("liter", L);
300  setVariable("litre", L);
301  setVariable("L", L);
302  setVariable("centiliter", centi_ * L);
303  setVariable("cL", centi_ * L);
304  setVariable("milliliter", milli_ * L);
305  setVariable("mL", milli_ * L);
306 
307  // Length^-1
308 
309  const double dpt = 1./m;
310  setVariable("diopter", dpt);
311  setVariable("dioptre", dpt);
312  setVariable("dpt", dpt);
313 
314  // Mass
315 
316  const double g = 0.001*kg;
317  setVariable("gram", g);
318  setVariable("g", g);
319  setVariable("milligram", milli_ * g);
320  setVariable("mg", milli_ * g);
321 
322  // Time
323 
324  setVariable("millisecond", milli_ * s);
325  setVariable("ms", milli_ * s);
326  setVariable("microsecond", micro_ * s);
327  setVariable("us", micro_ * s);
328  setVariable("nanosecond", nano_ * s);
329  setVariable("ns", nano_ * s);
330  setVariable("picosecond", pico_ * s);
331  setVariable("ps", pico_ * s);
332 
333  // Current
334 
335  setVariable("milliampere", milli_ * A);
336  setVariable("mA", milli_ * A);
337  setVariable("microampere", micro_ * A);
338  setVariable("nanoampere", nano_ * A);
339 
340  // Frequency
341 
342  setVariable("kilohertz", kilo_ * Hz);
343  setVariable("kHz", kilo_ * Hz);
344  setVariable("megahertz", mega_ * Hz);
345  setVariable("MHz", mega_ * Hz);
346 
347  // Force
348  setVariable("kilonewton", kilo_ * N);
349  setVariable("kN", kilo_ * N);
350 
351  // Pressure
352  setVariable("kilobar", kilo_ * bar);
353  setVariable("kbar", kilo_ * bar);
354  setVariable("millibar", milli_ * bar);
355  setVariable("mbar", milli_ * bar);
356 
357  // Energy
358  setVariable("kilojoule", kilo_ * J);
359  setVariable("kJ", kilo_ * J);
360  setVariable("megajoule", mega_ * J);
361  setVariable("MJ", mega_ * J);
362  setVariable("gigajoule", giga_ * J);
363  setVariable("GJ", giga_ * J);
364 
365  const double e_SI = 1.60217733e-19; // positron charge in coulomb
366  const double ePlus = e_SI * C; // positron charge
367  const double eV = ePlus * V;
368  setVariable("electronvolt", eV);
369  setVariable("eV", eV);
370  setVariable("kiloelectronvolt", kilo_ * eV);
371  setVariable("keV", kilo_ * eV);
372  setVariable("megaelectronvolt", mega_ * eV);
373  setVariable("MeV", mega_ * eV);
374  setVariable("gigaelectronvolt", giga_ * eV);
375  setVariable("GeV", giga_ * eV);
376  setVariable("teraelectronvolt", tera_ * eV);
377  setVariable("TeV", tera_ * eV);
378  setVariable("petaelectronvolt", peta_ * eV);
379  setVariable("PeV", peta_ * eV);
380 
381  // Power
382  setVariable("kilowatt", kilo_ * W);
383  setVariable("kW", kilo_ * W);
384  setVariable("megawatt", mega_ * W);
385  setVariable("MW", mega_ * W);
386  setVariable("gigawatt", giga_ * W);
387  setVariable("GW", giga_ * W);
388 
389  // Electric potential
390  setVariable("kilovolt", kilo_ * V);
391  setVariable("kV", kilo_ * V);
392  setVariable("megavolt", mega_ * V);
393  setVariable("MV", mega_ * V);
394 
395  // Electric capacitance
396  setVariable("millifarad", milli_ * F);
397  setVariable("mF", milli_ * F);
398  setVariable("microfarad", micro_ * F);
399  setVariable("uF", micro_ * F);
400  setVariable("nanofarad", nano_ * F);
401  setVariable("nF", nano_ * F);
402  setVariable("picofarad", pico_ * F);
403  setVariable("pF", pico_ * F);
404 
405  // Magnetic flux density
406  setVariable("kilogauss", kilo_ * Gs);
407  setVariable("kGs", kilo_ * Gs);
408 }
static constexpr double candela
Definition: G4SIunits.hh:317
const int N
Definition: mixmax.h:43
static constexpr double km
Definition: G4SIunits.hh:133
static constexpr double mm
Definition: G4SIunits.hh:115
double S(double temp)
static constexpr double Bq
Definition: G4SIunits.hh:298
static constexpr double e_SI
Definition: G4SIunits.hh:198
static constexpr double ampere
Definition: G4SIunits.hh:189
static const G4double cd
static constexpr double second
Definition: G4SIunits.hh:157
double C(double temp)
static constexpr double rad
Definition: G4SIunits.hh:149
static constexpr double g
Definition: G4SIunits.hh:183
static constexpr double meter
Definition: G4SIunits.hh:82
const XML_Char * s
Definition: expat.h:262
double A(double temperature)
static constexpr double m
Definition: G4SIunits.hh:129
static constexpr double cm
Definition: G4SIunits.hh:119
static constexpr double sr
Definition: G4SIunits.hh:151
static constexpr double eV
Definition: G4SIunits.hh:215
static constexpr double kg
Definition: G4SIunits.hh:182
static constexpr double kelvin
Definition: G4SIunits.hh:281
void setVariable(const char *name, double value)
Definition: Evaluator.cc:687
static constexpr double ohm
Definition: G4SIunits.hh:249
static constexpr double kilogram
Definition: G4SIunits.hh:177
static constexpr double pi
Definition: G4SIunits.hh:75
static constexpr double bar
Definition: G4SIunits.hh:236
static constexpr double deg
Definition: G4SIunits.hh:152
static constexpr double barn
Definition: G4SIunits.hh:105
static constexpr double L
Definition: G4SIunits.hh:124
static constexpr double mole
Definition: G4SIunits.hh:286

Here is the call graph for this function:

Here is the caller graph for this function:

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

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
namename of the variable.
valuevalue assigned to the variable.

Definition at line 687 of file Evaluator.cc.

688 { setItem("", name, Item(value), (Struct *)p); }
const XML_Char * name
Definition: expat.h:151
const char * p
Definition: xmltok.h:285
static void setItem(const char *prefix, const char *name, const Item &item, Struct *s)
Definition: Evaluator.cc:549
const XML_Char int const XML_Char * value
Definition: expat.h:331

Here is the call graph for this function:

Here is the caller graph for this function:

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

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
namename of the variable.
expressionarithmetic expression.

Definition at line 690 of file Evaluator.cc.

691 { setItem("", name, Item(expression), (Struct *)p); }
const XML_Char * name
Definition: expat.h:151
const char * p
Definition: xmltok.h:285
static void setItem(const char *prefix, const char *name, const Item &item, Struct *s)
Definition: Evaluator.cc:549

Here is the call graph for this function:

int HepTool::Evaluator::status ( ) const

Returns status of the last operation with the evaluator.

Definition at line 631 of file Evaluator.cc.

631  {
632  return ((Struct *)(p))->theStatus;
633 }
const char * p
Definition: xmltok.h:285

Here is the caller graph for this function:


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