G4tgrUtils Class Reference

#include <G4tgrUtils.hh>

Public Member Functions
	G4tgrUtils ()
	~G4tgrUtils ()

Static Public Member Functions
static G4bool	IsSeparator (char)
static G4bool	IsNumber (const G4String &str)
static G4bool	IsInteger (const G4double val, const G4double precision=1.e-6)
static G4bool	IsFunction (const G4String &word)
static G4bool	WordIsUnit (const G4String &word)
static void	Dump3v (const G4ThreeVector &vec, const char *msg)
static void	Dumprm (const G4RotationMatrix &rm, const char *msg)
static void	DumpVS (const std::vector< G4String > &wl, const char *msg)
static void	DumpVS (const std::vector< G4String > &wl, const char *msg, std::ostream &outs)
static void	CheckWLsize (const std::vector< G4String > &wl, unsigned int nWCheck, WLSIZEtype st, const G4String &methodName)
static G4bool	CheckListSize (unsigned int nWreal, unsigned int nWcheck, WLSIZEtype st, G4String &outstr)
static G4String	SubColon (const G4String &str)
static G4String	GetString (const G4String &str)
static G4double	GetDouble (const G4String &str, G4double unitval=1.)
static G4int	GetInt (const G4String &str)
static G4bool	GetBool (const G4String &str)
static G4RotationMatrix	GetRotationFromDirection (G4ThreeVector dir)
static G4bool	AreWordsEquivalent (const G4String &word1, const G4String &word2)

Detailed Description

Definition at line 55 of file G4tgrUtils.hh.

Constructor & Destructor Documentation

G4tgrUtils()

G4tgrUtils::G4tgrUtils

(

)

Definition at line 47 of file G4tgrUtils.cc.

{
  if(theEvaluator == nullptr)
  {
    theEvaluator = new G4tgrEvaluator;
  }
}

~G4tgrUtils()

G4tgrUtils::~G4tgrUtils

(

)

Definition at line 56 of file G4tgrUtils.cc.

{
  delete theEvaluator;
  theEvaluator = nullptr;
}

Member Function Documentation

AreWordsEquivalent()

G4bool G4tgrUtils::AreWordsEquivalent ( const G4String &  word1, const G4String &  word2  )

static

Definition at line 653 of file G4tgrUtils.cc.

{
  G4bool bEqual = true;
  std::vector<std::pair<size_t, size_t>> stringPairs;
  // start of substring, number of characters
 
  //--- Get string limits between asterisks in word1
 
  std::size_t cStart = 0;
  for(;;)
  {
    size_t cAster = word1.find("*", cStart);
    if(cAster != std::string::npos)
    {
      if(cAster == cStart)
      {
        if(cAster != 0)
        {
          G4Exception("G4tgrUtils::AreWordsEquivalent()",
                      "A word has two asterisks together, please correct it",
                      FatalException, ("Offending word is: " + word1).c_str());
        }
        else
        {
          // word1 == *
          if(word1.size() == 1)
          {
            return true;
          }
        }
      }
      if(cAster != cStart)
      {
        stringPairs.push_back(
          std::pair<size_t, size_t>(cStart, cAster - cStart));
      }
      cStart = cAster + 1;
    }
    else
    {
      if(cStart == 0)
      {
        //--- If there is no asterisk check if they are the same
        return word1 == word2;
      }
      break;
    }
  }
 
  //---- Add characters after last asterisk as string pair
  if(cStart <= word1.length())
  {
    if(word1.length() != cStart)
    {
      stringPairs.push_back(
        std::pair<size_t, size_t>(cStart, word1.length() - cStart));
    }
  }
 
  //--- If there are not asterisk, simple comparison
  if(stringPairs.size() == 0)
  {
    if(word1 == word2)
    {
      return true;
    }
    else
    {
      return false;
    }
  }
 
  //--- Find substrings in word2, in same order as in word1
  cStart = 0;
  for(std::size_t ii = 0; ii < stringPairs.size(); ++ii)
  {
    std::pair<size_t, size_t> spair = stringPairs[ii];
    size_t sFound = word2.find(word1.substr(spair.first, spair.second), cStart);
    if(sFound == std::string::npos)
    {
      bEqual = false;
      break;
    }
    else
    {
      //---- If there is no asterisk before first character,
      //     the fisrt string pair found has to start at the first character
      if(spair.first == 0 && sFound != 0)
      {
        bEqual = false;
        break;
        //---- If there is no asterisk after last character,
        //     the last string pair found has to end at the last character
      }
      else if((spair.first + spair.second - 1 == word1.length()) &&
              (sFound + spair.second - 1 != word2.length()))
      {
        bEqual = false;
        break;
      }
      cStart += spair.second;
    }
  }
 
  return bEqual;
}

Referenced by G4tgrVolumeMgr::FindVolumes().

CheckListSize()

G4bool G4tgrUtils::CheckListSize ( unsigned int  nWreal, unsigned int  nWcheck, WLSIZEtype  st, G4String &  outstr  )

static

Definition at line 512 of file G4tgrUtils.cc.

{
  G4bool isOK = true;
  switch(st)
  {
    case WLSIZE_EQ:
      if(nWreal != nWcheck)
      {
        isOK = false;
        outStr += G4String("not equal than ");
      }
      break;
    case WLSIZE_NE:
      if(nWreal == nWcheck)
      {
        isOK = false;
        outStr += G4String("equal than ");
      }
      break;
    case WLSIZE_LE:
      if(nWreal > nWcheck)
      {
        isOK = false;
        outStr += G4String("greater than ");
      }
      break;
    case WLSIZE_LT:
      if(nWreal >= nWcheck)
      {
        isOK = false;
        outStr += G4String("greater or equal than ");
      }
      break;
    case WLSIZE_GE:
      if(nWreal < nWcheck)
      {
        isOK = false;
        outStr += G4String("less than ");
      }
      break;
    case WLSIZE_GT:
      if(nWreal <= nWcheck)
      {
        isOK = false;
        outStr += G4String("less or equal than ");
      }
      break;
    default:
      G4cerr << " ERROR!! - G4tgrUtils::CheckListSize()" << G4endl
             << "           Type of WLSIZE type not found " << st << G4endl;
      break;
  }
 
  return isOK;
}

Referenced by G4tgbPlaceParameterisation::CheckNExtraData(), and CheckWLsize().

CheckWLsize()

void G4tgrUtils::CheckWLsize ( const std::vector< G4String > &  wl, unsigned int  nWCheck, WLSIZEtype  st, const G4String &  methodName  )

static

Definition at line 490 of file G4tgrUtils.cc.

{
  G4String outStr = methodName + G4String(".  Line read with number of words ");
  unsigned int wlsize = (unsigned int)wl.size();
 
  G4bool isOK = CheckListSize(wlsize, nWcheck, st, outStr);
 
  if(!isOK)
  {
    G4String chartmp = G4UIcommand::ConvertToString(G4int(nWcheck));
    outStr += chartmp + G4String(" words");
    DumpVS(wl, outStr.c_str());
    G4String ErrMessage =
      " NUMBER OF WORDS: " + G4UIcommand::ConvertToString(G4int(wlsize));
    G4Exception("G4tgrUtils::CheckWLsize()", "ParseError", FatalException,
                ErrMessage);
  }
}

Referenced by G4tgrVolume::AddCheckOverlaps(), G4tgrVolume::AddPlace(), G4tgrVolumeAssembly::AddPlace(), G4tgrVolume::AddPlaceReplica(), G4tgrVolume::AddRGBColour(), G4tgrVolume::AddVisibility(), G4tgrParameterMgr::CheckIfNewParameter(), G4tgrElementFromIsotopes::G4tgrElementFromIsotopes(), G4tgrElementSimple::G4tgrElementSimple(), G4tgrIsotope::G4tgrIsotope(), G4tgrMaterialMixture::G4tgrMaterialMixture(), G4tgrMaterialSimple::G4tgrMaterialSimple(), G4tgrPlaceDivRep::G4tgrPlaceDivRep(), G4tgrPlaceParameterisation::G4tgrPlaceParameterisation(), G4tgrVolumeAssembly::G4tgrVolumeAssembly(), and G4tgrVolumeDivision::G4tgrVolumeDivision().

Dump3v()

void G4tgrUtils::Dump3v ( const G4ThreeVector &  vec, const char *  msg  )

static

Definition at line 124 of file G4tgrUtils.cc.

{
  G4cout << msg << std::setprecision(8) << vec << std::setprecision(6)
         << G4endl;
}

Dumprm()

void G4tgrUtils::Dumprm ( const G4RotationMatrix &  rm, const char *  msg  )

static

Definition at line 131 of file G4tgrUtils.cc.

{
  G4cout << msg << G4endl << " xx=" << rm.xx() << " yx=" << rm.yx()
         << " zx=" << rm.zx() << G4endl << " xy=" << rm.xy()
         << " yy=" << rm.yy() << " zy=" << rm.zy() << G4endl
         << " xz=" << rm.xz() << " yz=" << rm.yz() << " zz=" << rm.zz()
         << G4endl;
}

DumpVS() [1/2]

void G4tgrUtils::DumpVS ( const std::vector< G4String > &  wl, const char *  msg  )

static

Definition at line 153 of file G4tgrUtils.cc.

{
  DumpVS(wl, msg, G4cout);
}

Referenced by G4tgrRotationMatrixFactory::AddRotMatrix(), CheckWLsize(), DumpVS(), G4tgrSolidBoolean::G4tgrSolidBoolean(), G4tgrSolidMultiUnion::G4tgrSolidMultiUnion(), G4tgrSolidScaled::G4tgrSolidScaled(), G4tgrLineProcessor::ProcessLine(), and G4tgrFileReader::ReadFiles().

DumpVS() [2/2]

void G4tgrUtils::DumpVS ( const std::vector< G4String > &  wl, const char *  msg, std::ostream &  outs  )

static

Definition at line 141 of file G4tgrUtils.cc.

{
  outs << msg << G4endl;
  for(auto ite = wl.cbegin(); ite != wl.cend(); ++ite)
  {
    outs << *ite << " ";
  }
  outs << G4endl;
}

GetBool()

G4bool G4tgrUtils::GetBool ( const G4String &  str )

static

Definition at line 464 of file G4tgrUtils.cc.

{
  G4bool val = false;
 
  //----------- first check that it is a not number
  if((str == "ON") || (str == "TRUE"))
  {
    val = true;
  }
  else if((str == "OFF") || (str == "FALSE"))
  {
    val = false;
  }
  else
  {
    G4String ErrMessage = G4String("Trying to get a float from a string") +
                          G4String(" which is not 'ON'/'OFF'/'TRUE'/'FALSE' ") +
                          str;
    G4Exception("G4tgrUtils::GetBool()", "ParseError", FatalException,
                ErrMessage);
  }
 
  return val;
}

Referenced by G4tgrVolume::AddCheckOverlaps(), and G4tgrVolume::AddVisibility().

GetDouble()

G4double G4tgrUtils::GetDouble ( const G4String &  str, G4double  unitval = 1.  )

static

Definition at line 198 of file G4tgrUtils.cc.

{
  if(!theEvaluator)
  {
    theEvaluator = new G4tgrEvaluator;
  }
#ifdef G4VERBOSE
  if(G4tgrMessenger::GetVerboseLevel() >= 3)
  {
    G4cout << "G4tgrUtils::GetDouble() - Processing: " << str
           << " default unit " << unitval << G4endl;
  }
#endif
  if(str == "DBL_MAX")
  {
    return DBL_MAX;
  }
  else if(str == "DBL_MIN")
  {
    return DBL_MIN;
  }
  else if(str == "FLT_MAX")
  {
    return FLT_MAX;
  }
  else if(str == "FLT_MIN")
  {
    return FLT_MIN;
  }
  else if(str == "INT_MAX")
  {
    return INT_MAX;
  }
  else if(str == "INT_MIN")
  {
    return INT_MIN;
  }
  //----- Look for arithmetic symbols, (, )
  const char* cstr = str.c_str();
  std::set<G4int> separators;
  separators.insert(-1);
  G4int strlen = G4int(str.length());
  for(G4int ii = 0; ii < strlen; ++ii)
  {
    char cs = cstr[ii];
    if(cs == '*' || cs == '/' || cs == '(' || cs == ')')
    {
      separators.insert(ii);
    }
    else if(cs == '+' || cs == '-')
    {
      // Check if it is not an exponential
      //
      if((ii < 2) || ((cstr[ii - 1] != 'E') && (cstr[ii - 1] != 'e')) ||
     !IsNumber(G4String(1,cstr[ii - 2])))
      {
        separators.insert(ii);
      }
    }
  }
  separators.insert(strlen);
  std::string strnew;  // build a new word with Parameters
                       // and units substituted by values
  //----- Process words, defined as characters between two separators
  G4int nUnits = 0;
  std::set<G4int>::const_iterator site, site2;
  site  = separators.cbegin();
  site2 = site;
  ++site2;
  for(; site2 != separators.cend(); ++site, ++site2)
  {
#ifdef G4VERBOSE
    if(G4tgrMessenger::GetVerboseLevel() >= 3)
    {
      G4cout << "   Loop to find word between " << *site << " " << *site2
             << G4endl;
    }
#endif
 
    if(*site != -1)
    {
      strnew += str.substr(*site, 1);
    }
 
    G4int wlen = (*site2) - (*site) - 1;  // do not count contiguous separators
    std::string word;
    if(wlen != 0)
    {
      word = str.substr((*site) + 1, (*site2) - (*site) - 1);
    }
    else
    {
      //--- Check combination of separators
      //--- Check number of parentheses
      continue;
    }
 
#ifdef G4VERBOSE
    if(G4tgrMessenger::GetVerboseLevel() >= 3)
    {
      G4cout << "   Processing word: " << word << G4endl;
    }
#endif
    //----------- first check if it is parameter
    const char* cword = word.c_str();
    if(cword[0] == '$')
    {
      G4String parstr = G4tgrParameterMgr::GetInstance()->FindParameter(
        word.substr(1, word.size()));
      if(parstr.substr(0, 1) == "-")
      {
        strnew += "(";
      }
      strnew += parstr;
      if(parstr.substr(0, 1) == "-")
      {
        strnew += ")";
      }
#ifdef G4VERBOSE
      if(G4tgrMessenger::GetVerboseLevel() >= 3)
      {
        G4cout << " G4tgrutils::GetDouble() - Param found: " << word
               << " in string " << str << " , substituted by " << parstr
               << G4endl;
      }
#endif
    }
    else
    {
      //----- Get if it is a number
      if(IsNumber(word))
      {
        //--- left separator cannot be ')'
        if((*site != -1) && (cstr[*site] == ')'))
        {
          G4String ErrMessage =
            "There cannot be a ')' before a number: " + word +
            " in string: " + str;
          G4Exception("G4tgrUtils::GetDouble()", "ParseError", FatalException,
                      ErrMessage);
        }
        //--- right separator cannot be '('
        if((*site2 != strlen) && (cstr[*site2] == '('))
        {
          G4String ErrMessage =
            "There cannot be a '(' after a number: " + word +
            " in string: " + str;
          G4Exception("G4tgrUtils::GetDouble()", "ParseError", FatalException,
                      ErrMessage);
        }
        strnew += word;
 
        //------ If it is an string, check if it is a unit
      }
      else
      {
        //--- First character cannot be a digit
        if(isdigit(word[0]))
        {
          G4String ErrMessage =
            "String words cannot start with a digit: " + word +
            " in string: " + str;
          G4Exception("G4tgrUtils::GetDouble()", "ParseError", FatalException,
                      ErrMessage);
        }
 
        //----- Check if it is a function
        G4bool bWordOK = false;
        if(G4tgrUtils::IsFunction(word))
        {
          //--- It must be followed by '('
          if((*site2 == strlen) || (cstr[*site2] != '('))
          {
            G4String ErrMessage =
              "There must be a '(' after a function: " + word +
              " in string: " + str;
            G4Exception("G4tgrUtils::GetDouble()", "ParseError", FatalException,
                        ErrMessage);
          }
          strnew += word;
          bWordOK = true;
          //----- Check if it is a unit
        }
        else if(G4tgrUtils::WordIsUnit(word))
        {
          //--- It must be preceded by a *
          if((*site == -1) || ((cstr[*site] != '*') && (cstr[*site] != '/')))
          {
            G4String ErrMess =
              "There must be a '*' before a unit definition: " + word +
              " in string " + str;
            G4Exception("G4tgrUtils::GetDouble()", "ParseError", FatalException,
                        ErrMess);
          }
          //--- check that it is indeed a CLHEP unit
          if(G4UnitDefinition::GetValueOf(word) != 0.)
          {
            bWordOK = true;
            nUnits++;
            if(nUnits > 1)
            {
              // G4String ErrMess = "There cannot be two unit definitions: "
              //                  + word + " in string " + str;
              // G4Exception("G4tgrUtils::GetDouble()", "ParseError",
              //             FatalException, ErrMess );
            }
            strnew +=
              G4UIcommand::ConvertToString(G4UnitDefinition::GetValueOf(word));
          }
        }
        if(!bWordOK)
        {
          G4String ErrMess = "String word is not a parameter, nor a unit\n" +
                             G4String("definition nor a function: ") + word +
                             G4String(" in string: ") + str;
          G4Exception("G4tgrUtils::GetDouble()", "ParseError", FatalException,
                      ErrMess);
        }
      }
    }
  }
 
  G4double val = theEvaluator->evaluate(strnew.c_str());
  if(theEvaluator->status() != HepTool::Evaluator::OK)
  {
    theEvaluator->print_error(theEvaluator->status());
    G4String ErrMessage = "Evaluator error: " + strnew;
    G4Exception("G4tgrUtils::GetDouble()", "ParseError", FatalException,
                ErrMessage);
  }
 
  if(nUnits == 0)
  {
    val *= unitval;
  }
 
#ifdef G4VERBOSE
  if(G4tgrMessenger::GetVerboseLevel() >= 3)
  {
    G4cout << " G4tgrUtils::GetDouble() - RESULT= " << val << G4endl
           << "   from string: " << str << " converted to: " << strnew.c_str()
           << " with unit val: " << unitval << G4endl;
  }
#endif
 
  return val;
}

Referenced by G4tgrParameterMgr::AddParameterNumber(), G4tgrVolume::AddPlaceReplica(), G4tgrVolume::AddRGBColour(), G4tgrElementFromIsotopes::G4tgrElementFromIsotopes(), G4tgrElementSimple::G4tgrElementSimple(), G4tgrIsotope::G4tgrIsotope(), G4tgrMaterialMixture::G4tgrMaterialMixture(), G4tgrMaterialSimple::G4tgrMaterialSimple(), G4tgrPlaceDivRep::G4tgrPlaceDivRep(), G4tgrPlaceParameterisation::G4tgrPlaceParameterisation(), G4tgrPlaceSimple::G4tgrPlaceSimple(), G4tgrRotationMatrix::G4tgrRotationMatrix(), G4tgrSolidBoolean::G4tgrSolidBoolean(), G4tgrSolidMultiUnion::G4tgrSolidMultiUnion(), G4tgrSolidScaled::G4tgrSolidScaled(), G4tgrVolumeAssembly::G4tgrVolumeAssembly(), G4tgrVolumeDivision::G4tgrVolumeDivision(), GetInt(), and G4tgrLineProcessor::ProcessLine().

GetInt()

G4int G4tgrUtils::GetInt ( const G4String &  str )

static

Definition at line 447 of file G4tgrUtils.cc.

{
  //----- Convert it to a number (it can be a parameter)
  G4double val = GetDouble(str);
 
  //----- Check it is an integer
  if(!IsInteger(val))
  {
    G4String ErrMessage = G4String("Trying to get the integer from a number") +
                          G4String(" which is not an integer ") + str;
    G4Exception("G4tgrUtils::GetInt()", "ParseError", FatalException,
                ErrMessage);
  }
  return G4int(val);
}

Referenced by G4tgrElementFromIsotopes::G4tgrElementFromIsotopes(), G4tgrElementSimple::G4tgrElementSimple(), G4tgrIsotope::G4tgrIsotope(), G4tgrMaterialMixture::G4tgrMaterialMixture(), G4tgrPlaceDivRep::G4tgrPlaceDivRep(), G4tgrPlaceParameterisation::G4tgrPlaceParameterisation(), G4tgrPlaceSimple::G4tgrPlaceSimple(), G4tgrSolidMultiUnion::G4tgrSolidMultiUnion(), G4tgrVolumeAssembly::G4tgrVolumeAssembly(), and G4tgrVolumeDivision::G4tgrVolumeDivision().

GetRotationFromDirection()

G4RotationMatrix G4tgrUtils::GetRotationFromDirection ( G4ThreeVector  dir )

static

Definition at line 608 of file G4tgrUtils.cc.

{
  G4RotationMatrix rotation;
 
  if(std::fabs(dir.mag() - 1.) >
     G4GeometryTolerance::GetInstance()->GetSurfaceTolerance())
  {
    G4String WarMessage = "Direction cosines have been normalized to one.\n" +
                          G4String("They were normalized to ") +
                          G4UIcommand::ConvertToString(dir.mag());
    G4Exception("G4tgrUtils::GetRotationFromDirection()", "WrongArgument",
                JustWarning, WarMessage);
    dir /= dir.mag();
  }
  G4double angx = -std::asin(dir.y());
 
  // There are always two solutions angx, angy and PI-angx,
  // PI+angy, choose first
  //
  G4double angy;
  if(dir.y() == 1.)
  {
    angy = 0.;
  }
  else if(dir.y() == 0.)
  {
    angy = 0.;
  }
  else
  {
    angy = std::asin(dir.x() / std::sqrt(1 - dir.y() * dir.y()));
  }
 
  // choose between  angy and PI-angy
  if(dir.z() * std::cos(angx) * std::cos(angy) < 0)
  {
    angy = pi - angy;
  }
  rotation.rotateX(angx);
  rotation.rotateY(angy);
 
  return rotation;
}

GetString()

G4String G4tgrUtils::GetString ( const G4String &  str )

static

Definition at line 173 of file G4tgrUtils.cc.

{
  //----------- first check if it is parameter
  const char* cstr = str.c_str();
  if(cstr[0] == '$')
  {
#ifdef G4VERBOSE
    if(G4tgrMessenger::GetVerboseLevel() >= 3)
    {
      G4cout << " G4tgrUtils::GetString() - Substitute parameter: "
             << G4tgrParameterMgr::GetInstance()->FindParameter(
                  str.substr(1, str.size()))
             << G4endl;
    }
#endif
    return G4tgrParameterMgr::GetInstance()->FindParameter(
      str.substr(1, str.size()));
  }
  else
  {
    return str;
  }
}

Referenced by G4tgrMaterialFactory::AddElementFromIsotopes(), G4tgrMaterialFactory::AddElementSimple(), G4tgrMaterialFactory::AddIsotope(), G4tgrMaterialFactory::AddMaterialMixture(), G4tgrMaterialFactory::AddMaterialSimple(), G4tgrRotationMatrixFactory::AddRotMatrix(), G4tgrElementFromIsotopes::G4tgrElementFromIsotopes(), G4tgrElementSimple::G4tgrElementSimple(), G4tgrIsotope::G4tgrIsotope(), G4tgrMaterialMixture::G4tgrMaterialMixture(), G4tgrMaterialSimple::G4tgrMaterialSimple(), G4tgrPlaceDivRep::G4tgrPlaceDivRep(), G4tgrPlaceParameterisation::G4tgrPlaceParameterisation(), G4tgrPlaceSimple::G4tgrPlaceSimple(), G4tgrRotationMatrix::G4tgrRotationMatrix(), G4tgrSolid::G4tgrSolid(), G4tgrSolidBoolean::G4tgrSolidBoolean(), G4tgrSolidMultiUnion::G4tgrSolidMultiUnion(), G4tgrSolidScaled::G4tgrSolidScaled(), G4tgrVolume::G4tgrVolume(), G4tgrVolumeAssembly::G4tgrVolumeAssembly(), G4tgrVolumeDivision::G4tgrVolumeDivision(), and G4tgrLineProcessor::ProcessLine().

IsFunction()

G4bool G4tgrUtils::IsFunction ( const G4String &  word )

static

Definition at line 591 of file G4tgrUtils.cc.

{
  if(word == "sin" || word == "cos" || word == "tan" || word == "asin" ||
     word == "acos" || word == "atan" || word == "atan2" || word == "sinh" ||
     word == "cosh" || word == "tanh" || word == "asinh" || word == "acosh" ||
     word == "atanh" || word == "sqrt" || word == "exp" || word == "log" ||
     word == "log10" || word == "pow")
  {
    return true;
  }
  else
  {
    return false;
  }
}

Referenced by GetDouble().

IsInteger()

G4bool G4tgrUtils::IsInteger ( const G4double  val, const G4double  precision = 1.e-6  )

static

Definition at line 111 of file G4tgrUtils.cc.

{
  if(G4int(val) / val - 1 > precision)
  {
    return false;
  }
  else
  {
    return true;
  }
}

Referenced by GetInt().

IsNumber()

G4bool G4tgrUtils::IsNumber ( const G4String &  str )

static

Definition at line 77 of file G4tgrUtils.cc.

{
  G4int isnum = 1;
  G4int numE  = 0;
  for(G4int ii = 0; ii < (G4int)str.length(); ++ii)
  {
    if(!isdigit(str[ii]) && (str[ii] != '.') && (str[ii] != '-') &&
       (str[ii] != '+'))
    {
      //--- check for E(xponential)
      if(str[ii] == 'E' || str[ii] == 'e')
      {
        if(ii == 0)
        {
          return 0;
        }
        if(numE != 0 || ii == G4int(str.length() - 1))
        {
          isnum = 0;
          break;
        }
        numE++;
      }
      else
      {
        isnum = 0;
        break;
      }
    }
  }
  return isnum;
}

Referenced by GetDouble(), and WordIsUnit().

IsSeparator()

G4bool G4tgrUtils::IsSeparator ( char  ch )

static

Definition at line 63 of file G4tgrUtils.cc.

{
  char nonCharacters[7] = { "()+-*/" };
  for(std::size_t ii = 0; ii < 6; ++ii)
  {
    if(ch == nonCharacters[ii])
    {
      return true;
    }
  }
  return false;
}

SubColon()

G4String G4tgrUtils::SubColon ( const G4String &  str )

static

Definition at line 159 of file G4tgrUtils.cc.

{
  if(str.find(':') != 0)
  {
    G4String ErrMessage = "Trying to subtract leading colon from a word\n" +
                          G4String("that has no leading colon: ") + str;
    G4Exception("G4tgrUtils::SubColon()", "ParseError", FatalException,
                ErrMessage);
  }
  G4String strt = str.substr(1, str.size() - 1);
  return strt;
}

WordIsUnit()

G4bool G4tgrUtils::WordIsUnit ( const G4String &  word )

static

Definition at line 570 of file G4tgrUtils.cc.

{
  return !IsNumber(word);
  if(word == "mm" || word == "cm" || word == "m" || word == "km" ||
     word == "millimeter" || word == "centimeter" || word == "meter" ||
     word == "kilometer" || word == "parsec" || word == "micrometer" ||
     word == "nanometer" || word == "angstrom" || word == "fermi" ||
     word == "nm" || word == "um" || word == "pc" || word == "radian" ||
     word == "milliradian" || word == "degree" || word == "rad" ||
     word == "mrad" || word == "deg" || word == "ns" || word == "becquerel" ||
     word == "curie")
  {
    return true;
  }
  else
  {
    return false;
  }
}

Referenced by GetDouble().

---

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

• G4tgrUtils.hh
• G4tgrUtils.cc