Changeset 850 for trunk/source/persistency/gdml/src/G4GDMLEvaluator.cc

Timestamp:

Sep 10, 2008, 5:40:37 PM (16 years ago)

Author:

garnier

Message:

geant4.8.2 beta

File:

• trunk/source/persistency/gdml/src/G4GDMLEvaluator.cc (modified) (3 diffs)

trunk/source/persistency/gdml/src/G4GDMLEvaluator.cc

@@ -25 +25 @@
 //
 //
-// $Id: G4GDMLEvaluator.cc,v 1.11 2007/11/28 10:27:18 ztorzsok Exp $
+// $Id: G4GDMLEvaluator.cc,v 1.20 2008/07/16 15:46:34 gcosmo Exp $
 // GEANT4 tag $ Name:$
 //
@@ -34 +34 @@
 // --------------------------------------------------------------------
 
+#include <sstream>
 #include "G4GDMLEvaluator.hh"
 
-G4GDMLEvaluator::G4GDMLEvaluator() {
-
+G4GDMLEvaluator::G4GDMLEvaluator()
+{
    eval.clear();
    eval.setStdMath();
-   eval.setSystemOfUnits(1.e+3,1./1.60217733e-25,1.e+9,1./1.60217733e-10,1.0,1.0,1.0);
-}
-
-void G4GDMLEvaluator::defineConstant(const G4String& name,G4double value) {
-
-   if (eval.findVariable(name)) G4Exception("GDML: Constant or variable '"+name+"' is already defined!");
-
+   eval.setSystemOfUnits(meter,kilogram,second,ampere,kelvin,mole,candela);
+}
+
+void G4GDMLEvaluator::DefineConstant(const G4String& name, G4double value)
+{
+   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);
 }
 
-void G4GDMLEvaluator::defineVariable(const G4String& name,G4double value) {
-
-   if (eval.findVariable(name)) G4Exception("GDML: Constant or variable '"+name+"' is already defined!");
-
+void G4GDMLEvaluator::DefineVariable(const G4String& name,G4double value)
+{
+   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);
 }
 
-void G4GDMLEvaluator::setVariable(const G4String& name,G4double value) {
-
-   checkVariable(name);
-
+void G4GDMLEvaluator::DefineMatrix(const G4String& name,
+                                         G4int coldim,
+                                         std::vector<G4double> valueList)
+{
+   const G4int size = 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]);
+        }
+      }
+   }
+}
+
+void G4GDMLEvaluator::SetVariable(const G4String& name, G4double value)
+{
+   if (!IsVariable(name))
+   {
+     G4String error_msg = "Variable '" + name + "' is not defined!";
+     G4Exception("G4GDMLEvaluator::SetVariable()", "InvalidSetup",
+                 FatalException, error_msg);
+   }
    eval.setVariable(name.c_str(),value);
 }
 
-void G4GDMLEvaluator::checkVariable(const G4String& name) {
-
-   for (std::vector<G4String>::iterator iter = variableList.begin(); iter != variableList.end(); iter++) {
-
-      if (name == *iter) return;
-   }
-
-   G4Exception("GDML: Variable '"+name+"' is not defined!");
-}
-
-G4double G4GDMLEvaluator::Evaluate(const G4String& expression) {
+G4bool G4GDMLEvaluator::IsVariable(const G4String& name) const
+{
+   const size_t variableCount = variableList.size();
+
+   for (size_t i=0;i<variableCount;i++)
+   {
+      if (variableList[i] == name)  { return true; }
+   }
+
+   return false;
+}
+
+G4String G4GDMLEvaluator::SolveBrackets(const G4String& in)
+{
+   const std::string::size_type open = in.find("[",0);
+   const std::string::size_type close = in.find("]",0);
+
+   if (open==close) { return in; }
+
+   if (open>close)
+   {
+     G4String error_msg = "Bracket mismatch: " + in;
+     G4Exception("G4GDMLEvaluator::SolveBrackets()", "InvalidExpression",
+                 FatalException, error_msg);
+   }
+
+   std::string::size_type begin = open;
+   std::string::size_type end = 0;
+
+   std::string out;
+   out.append(in,0,open);
+   
+   do
+   {
+      end = in.find(",",begin+1);
+      if (end==std::string::npos)  { end = close; }
+
+      std::stringstream indexStream;
+      indexStream << "_" << EvaluateInteger(in.substr(begin+1,end-begin-1));
+
+      out.append(indexStream.str());
+
+      begin = end;
+
+   } while (end<close);
+
+   return out;
+}
+
+G4double G4GDMLEvaluator::Evaluate(const G4String& in)
+{
+   G4String expression = SolveBrackets(in);
 
    G4double value = 0.0;
 
-   if (!expression.empty()) {
-   
+   if (!expression.empty())
+   {
       value = eval.evaluate(expression.c_str());
 
-      if (eval.status() != HepTool::Evaluator::OK) {
-
+      if (eval.status() != HepTool::Evaluator::OK)
+      {
          eval.print_error();
-         G4Exception("Error in evaluator!");
+         G4String error_msg = "Error in expression: " + expression;
+         G4Exception("G4GDMLEvaluator::Evaluate()", "InvalidExpression",
+                     FatalException, error_msg);
       }
    }
-   
    return value;
 }
 
-G4int G4GDMLEvaluator::EvaluateInteger(const G4String& expression) {
+G4int G4GDMLEvaluator::EvaluateInteger(const G4String& expression)
+{
+   // 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);
@@ -100 +212 @@
    G4double frac = value - (G4double)whole;
 
-   if (frac != 0.0) G4Exception("GDML: Expression '"+expression+"' is expected to have an integer value!");
-
+   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;
 }
+
+G4double G4GDMLEvaluator::GetConstant(const G4String& name)
+{
+   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);
+}
+
+G4double G4GDMLEvaluator::GetVariable(const G4String& name)
+{
+   if (!IsVariable(name))
+   {
+     G4String error_msg = "Variable '" + name + "' is not a defined!";
+     G4Exception("G4GDMLEvaluator::GetVariable()", "InvalidSetup",
+                 FatalException, error_msg);
+   }
+   return Evaluate(name);
+}