#include <G4UIcmdWithADoubleAndUnit.hh>

Inheritance diagram for G4UIcmdWithADoubleAndUnit:

Public Types
enum	CommandType { BaseClassCmd , WithoutParameterCmd , WithABoolCmd , WithAnIntegerCmd , WithALongIntCmd , WithADoubleCmd , WithADoubleAndUnitCmd , With3VectorCmd , With3VectorAndUnitCmd , WithAStringCmd , CmdDirectory = -1 }

Public Member Functions
void	AvailableForStates (G4ApplicationState s1)

void	AvailableForStates (G4ApplicationState s1, G4ApplicationState s2)

void	AvailableForStates (G4ApplicationState s1, G4ApplicationState s2, G4ApplicationState s3)

void	AvailableForStates (G4ApplicationState s1, G4ApplicationState s2, G4ApplicationState s3, G4ApplicationState s4)

void	AvailableForStates (G4ApplicationState s1, G4ApplicationState s2, G4ApplicationState s3, G4ApplicationState s4, G4ApplicationState s5)

void	CommandFailed (G4ExceptionDescription &ed)

void	CommandFailed (G4int errCode, G4ExceptionDescription &ed)

G4String	ConvertToStringWithBestUnit (G4double val)

G4String	ConvertToStringWithDefaultUnit (G4double val)

virtual G4int	DoIt (G4String parameterList)

	G4UIcmdWithADoubleAndUnit (const char theCommandPath, G4UImessenger theMessenger)

const G4String &	GetCommandName () const

const G4String &	GetCommandPath () const

CommandType	GetCommandType () const

G4String	GetCurrentValue ()

const G4String &	GetFailureDescription ()

std::size_t	GetGuidanceEntries () const

const G4String &	GetGuidanceLine (G4int i) const

G4UImessenger *	GetMessenger () const

G4UIparameter *	GetParameter (G4int i) const

std::size_t	GetParameterEntries () const

const G4String &	GetRange () const

std::vector< G4ApplicationState > *	GetStateList ()

const G4String	GetTitle () const

G4int	IfCommandFailed ()

G4bool	IsAvailable ()

G4bool	IsWorkerThreadOnly () const

virtual void	List ()

G4bool	operator!= (const G4UIcommand &right) const

G4bool	operator== (const G4UIcommand &right) const

void	ResetFailure ()

void	SetCommandType (CommandType)

void	SetDefaultSortFlag (G4bool val)

void	SetDefaultUnit (const char *defUnit)

void	SetDefaultValue (G4double defVal)

void	SetGuidance (const char *aGuidance)

void	SetParameter (G4UIparameter *const newParameter)

void	SetParameterName (const char *theName, G4bool omittable, G4bool currentAsDefault=false)

void	SetRange (const char *rs)

void	SetToBeBroadcasted (G4bool val)

void	SetToBeFlushed (G4bool val)

void	SetUnitCandidates (const char *candidateList)

void	SetUnitCategory (const char *unitCategory)

void	SetWorkerThreadOnly (G4bool val=true)

G4bool	ToBeBroadcasted () const

G4bool	ToBeFlushed () const

Static Public Member Functions
static G4String	CategoryOf (const char *unitName)

static G4ThreeVector	ConvertTo3Vector (const char *st)

static G4bool	ConvertToBool (const char *st)

static G4ThreeVector	ConvertToDimensioned3Vector (const char *st)

static G4double	ConvertToDimensionedDouble (const char *st)

static G4double	ConvertToDouble (const char *st)

static G4int	ConvertToInt (const char *st)

static G4long	ConvertToLongInt (const char *st)

static G4String	ConvertToString (G4bool boolVal)

static G4String	ConvertToString (G4double doubleValue)

static G4String	ConvertToString (G4double doubleValue, const char *unitName)

static G4String	ConvertToString (G4int intValue)

static G4String	ConvertToString (G4long longValue)

static G4String	ConvertToString (G4ThreeVector vec)

static G4String	ConvertToString (G4ThreeVector vec, const char *unitName)

static G4double	GetNewDoubleRawValue (const char *paramString)

static G4double	GetNewDoubleValue (const char *paramString)

static G4double	GetNewUnitValue (const char *paramString)

static G4String	UnitsList (const char *unitCategory)

static G4double	ValueOf (const char *unitName)

Protected Types
using	tokenNum = G4UItokenNum::tokenNum

using	yystype = G4UItokenNum::yystype

Protected Member Functions
G4int	CheckNewValue (const char *newValue)

Protected Attributes
G4int	commandFailureCode = 0

G4String	failureDescription = ""

G4bool	ifSort = false

G4bool	toBeBroadcasted = false

G4bool	toBeFlushed = false

G4bool	workerThreadOnly = false

Private Member Functions
yystype	AdditiveExpression (void)

G4int	Backslash (G4int c)

G4int	CompareDouble (G4double arg1, G4int op, G4double arg2)

G4int	CompareInt (G4int arg1, G4int op, G4int arg2)

G4int	CompareLong (G4long arg1, G4int op, G4long arg2)

yystype	EqualityExpression (void)

G4int	Eval2 (yystype arg1, G4int op, yystype arg2)

G4int	ExpectExponent (const char *str)

yystype	Expression (void)

G4int	Follow (G4int expect, G4int ifyes, G4int ifno)

void	G4UIcommandCommonConstructorCode (const char *theCommandPath)

G4int	G4UIpGetc (void)

G4int	G4UIpUngetc (G4int c)

unsigned	IndexOf (const char *)

G4int	IsDouble (const char *str)

G4int	IsInt (const char *str, short maxLength)

unsigned	IsParameter (const char *)

yystype	LogicalANDExpression (void)

yystype	LogicalORExpression (void)

yystype	MultiplicativeExpression (void)

yystype	PrimaryExpression (void)

G4int	RangeCheck (const char *t)

yystype	RelationalExpression (void)

G4int	TypeCheck (const char *t)

yystype	UnaryExpression (void)

tokenNum	Yylex (void)

Private Attributes
std::vector< G4ApplicationState >	availabelStateList

G4int	bp = 0

std::vector< G4String >	commandGuidance

G4String	commandName

G4String	commandPath

CommandType	commandType = BaseClassCmd

G4UImessenger *	messenger = nullptr

std::vector< yystype >	newVal

G4int	paramERR = 0

std::vector< G4UIparameter * >	parameter

G4String	rangeBuf

G4String	rangeString

tokenNum	token = G4UItokenNum::IDENTIFIER

yystype	yylval

Detailed Description

Definition at line 41 of file G4UIcmdWithADoubleAndUnit.hh.

Member Typedef Documentation

◆ tokenNum

using G4UIcommand::tokenNum = G4UItokenNum::tokenNum

protectedinherited

Definition at line 215 of file G4UIcommand.hh.

◆ yystype

using G4UIcommand::yystype = G4UItokenNum::yystype

protectedinherited

Definition at line 214 of file G4UIcommand.hh.

Member Enumeration Documentation

◆ CommandType

enum G4UIcommand::CommandType

inherited

Enumerator
BaseClassCmd
WithoutParameterCmd
WithABoolCmd
WithAnIntegerCmd
WithALongIntCmd
WithADoubleCmd
WithADoubleAndUnitCmd
With3VectorCmd
With3VectorAndUnitCmd
WithAStringCmd
CmdDirectory

Definition at line 198 of file G4UIcommand.hh.

    { BaseClassCmd, WithoutParameterCmd,
      WithABoolCmd, WithAnIntegerCmd, WithALongIntCmd, 
      WithADoubleCmd, WithADoubleAndUnitCmd, With3VectorCmd, With3VectorAndUnitCmd,
      WithAStringCmd, CmdDirectory = -1 };

Constructor & Destructor Documentation

◆ G4UIcmdWithADoubleAndUnit()

G4UIcmdWithADoubleAndUnit::G4UIcmdWithADoubleAndUnit	(	const char *	theCommandPath,
		G4UImessenger *	theMessenger
	)

Definition at line 39 of file G4UIcmdWithADoubleAndUnit.cc.

  : G4UIcommand(theCommandPath, theMessenger)
{
  G4UIparameter* dblParam = new G4UIparameter('d');
  SetParameter(dblParam);
  G4UIparameter* untParam = new G4UIparameter('s');
  untParam->SetParameterName("Unit");
  SetParameter(untParam);
  SetCommandType(WithADoubleAndUnitCmd);
}

References G4UIcommand::SetCommandType(), G4UIcommand::SetParameter(), G4UIparameter::SetParameterName(), and G4UIcommand::WithADoubleAndUnitCmd.

Member Function Documentation

◆ AdditiveExpression()

yystype G4UIcommand::AdditiveExpression ( void )

privateinherited

Definition at line 1063 of file G4UIcommand.cc.

{
  yystype result;
  result = MultiplicativeExpression();
  if(token != '+' && token != '-')
    return result;
  G4cerr << "Parameter range: operator " << (char) token << " is not supported."
         << G4endl;
  paramERR = 1;
  return result;
}

References G4cerr, G4endl, G4UIcommand::MultiplicativeExpression(), G4UIcommand::paramERR, and G4UIcommand::token.

Referenced by G4UIcommand::RelationalExpression().

◆ AvailableForStates() [1/5]

void G4UIcommand::AvailableForStates ( G4ApplicationState s1 )

inherited

Definition at line 288 of file G4UIcommand.cc.

{
  availabelStateList.clear();
  availabelStateList.push_back(s1);
}

References G4UIcommand::availabelStateList.

Referenced by DetectorMessenger::DetectorMessenger(), ExN03DetectorMessenger::ExN03DetectorMessenger(), G4AdjointSimMessenger::G4AdjointSimMessenger(), G4DeexParametersMessenger::G4DeexParametersMessenger(), G4EmExtraParametersMessenger::G4EmExtraParametersMessenger(), G4EmLowEParametersMessenger::G4EmLowEParametersMessenger(), G4EmMessenger::G4EmMessenger(), G4EmParametersMessenger::G4EmParametersMessenger(), G4ErrorMessenger::G4ErrorMessenger(), G4EvManMessenger::G4EvManMessenger(), G4FastSimulationMessenger::G4FastSimulationMessenger(), G4GDMLMessenger::G4GDMLMessenger(), G4GeometryMessenger::G4GeometryMessenger(), G4GlobalMagFieldMessenger::G4GlobalMagFieldMessenger(), G4GMocrenMessenger::G4GMocrenMessenger(), G4HadronicParametersMessenger::G4HadronicParametersMessenger(), G4HepRepMessenger::G4HepRepMessenger(), G4INCLXXInterfaceMessenger::G4INCLXXInterfaceMessenger(), G4LocalThreadCoutMessenger::G4LocalThreadCoutMessenger(), G4MatScanMessenger::G4MatScanMessenger(), G4NeutronKillerMessenger::G4NeutronKillerMessenger(), G4NuclideTableMessenger::G4NuclideTableMessenger(), G4OpticalParametersMessenger::G4OpticalParametersMessenger(), G4ParticleHPMessenger::G4ParticleHPMessenger(), G4ParticleMessenger::G4ParticleMessenger(), G4ParticlePropertyMessenger::G4ParticlePropertyMessenger(), G4PhysListFactoryMessenger::G4PhysListFactoryMessenger(), G4PolarizationMessenger::G4PolarizationMessenger(), G4ProcessManagerMessenger::G4ProcessManagerMessenger(), G4ProcessTableMessenger::G4ProcessTableMessenger(), G4ProductionCutsTableMessenger::G4ProductionCutsTableMessenger(), G4RTMessenger::G4RTMessenger(), G4RunMessenger::G4RunMessenger(), G4SchedulerMessenger::G4SchedulerMessenger(), G4StackingMessenger::G4StackingMessenger(), G4UCNBoundaryProcessMessenger::G4UCNBoundaryProcessMessenger(), G4UserPhysicsListMessenger::G4UserPhysicsListMessenger(), GFlashShowerModelMessenger::GFlashShowerModelMessenger(), PhysicsListMessenger::PhysicsListMessenger(), and G4GenericMessenger::Command::SetStates().

◆ AvailableForStates() [2/5]

void G4UIcommand::AvailableForStates	(	G4ApplicationState	s1,
		G4ApplicationState	s2
	)

inherited

Definition at line 295 of file G4UIcommand.cc.

{
  availabelStateList.clear();
  availabelStateList.push_back(s1);
  availabelStateList.push_back(s2);
}

References G4UIcommand::availabelStateList.

◆ AvailableForStates() [3/5]

void G4UIcommand::AvailableForStates	(	G4ApplicationState	s1,
		G4ApplicationState	s2,
		G4ApplicationState	s3
	)

inherited

Definition at line 304 of file G4UIcommand.cc.

{
  availabelStateList.clear();
  availabelStateList.push_back(s1);
  availabelStateList.push_back(s2);
  availabelStateList.push_back(s3);
}

References G4UIcommand::availabelStateList.

◆ AvailableForStates() [4/5]

void G4UIcommand::AvailableForStates	(	G4ApplicationState	s1,
		G4ApplicationState	s2,
		G4ApplicationState	s3,
		G4ApplicationState	s4
	)

inherited

Definition at line 315 of file G4UIcommand.cc.

{
  availabelStateList.clear();
  availabelStateList.push_back(s1);
  availabelStateList.push_back(s2);
  availabelStateList.push_back(s3);
  availabelStateList.push_back(s4);
}

References G4UIcommand::availabelStateList.

◆ AvailableForStates() [5/5]

void G4UIcommand::AvailableForStates	(	G4ApplicationState	s1,
		G4ApplicationState	s2,
		G4ApplicationState	s3,
		G4ApplicationState	s4,
		G4ApplicationState	s5
	)

inherited

Definition at line 328 of file G4UIcommand.cc.

{
  availabelStateList.clear();
  availabelStateList.push_back(s1);
  availabelStateList.push_back(s2);
  availabelStateList.push_back(s3);
  availabelStateList.push_back(s4);
  availabelStateList.push_back(s5);
}

References G4UIcommand::availabelStateList.

◆ Backslash()

G4int G4UIcommand::Backslash ( G4int c )

privateinherited

◆ CategoryOf()

G4String G4UIcommand::CategoryOf ( const char * unitName )

staticinherited

Definition at line 371 of file G4UIcommand.cc.

{
  return G4UnitDefinition::GetCategory(unitName);
}

References G4UnitDefinition::GetCategory().

Referenced by ConvertToStringWithBestUnit(), G4UIcmdWith3VectorAndUnit::ConvertToStringWithBestUnit(), G4UIcmdWith3VectorAndUnit::DoIt(), DoIt(), G4MatScanMessenger::G4MatScanMessenger(), G4UserPhysicsListMessenger::G4UserPhysicsListMessenger(), G4UIcmdWith3VectorAndUnit::SetDefaultUnit(), SetDefaultUnit(), and G4UIparameter::SetDefaultUnit().

◆ CheckNewValue()

G4int G4UIcommand::CheckNewValue ( const char * newValue )

protectedinherited

Definition at line 625 of file G4UIcommand.cc.

{
  yystype result;
  // if( TypeCheck(newValue) == 0 ) return 1;
  if(!rangeString.empty())
  {
    if(RangeCheck(newValue) == 0)
      return fParameterOutOfRange;
  }
  return 0;  // succeeded
}

References fParameterOutOfRange, G4UIcommand::RangeCheck(), and G4UIcommand::rangeString.

Referenced by G4UIcommand::DoIt().

◆ CommandFailed() [1/2]

void G4UIcommand::CommandFailed ( G4ExceptionDescription & ed )

inlineinherited

Definition at line 184 of file G4UIcommand.hh.

    {
      commandFailureCode = 1;
      failureDescription = ed.str();
    }

References G4UIcommand::commandFailureCode, and G4UIcommand::failureDescription.

◆ CommandFailed() [2/2]

void G4UIcommand::CommandFailed	(	G4int	errCode,
		G4ExceptionDescription &	ed
	)

inlineinherited

Definition at line 179 of file G4UIcommand.hh.

    {
      commandFailureCode = errCode;
      failureDescription = ed.str();
    }

References G4UIcommand::commandFailureCode, and G4UIcommand::failureDescription.

◆ CompareDouble()

G4int G4UIcommand::CompareDouble	(	G4double	arg1,
		G4int	op,
		G4double	arg2
	)

privateinherited

Definition at line 1432 of file G4UIcommand.cc.

{
  G4int result = -1;
  G4String opr;
  switch(op)
  {
    case GT:
      result = (arg1 > arg2);
      opr    = ">";
      break;
    case GE:
      result = (arg1 >= arg2);
      opr    = ">=";
      break;
    case LT:
      result = (arg1 < arg2);
      opr    = "<";
      break;
    case LE:
      result = (arg1 <= arg2);
      opr    = "<=";
      break;
    case EQ:
      result = (arg1 == arg2);
      opr    = "==";
      break;
    case NE:
      result = (arg1 != arg2);
      opr    = "!=";
      break;
    default:
      G4cerr << "Parameter range: error at CompareDouble" << G4endl;
      paramERR = 1;
  }
#ifdef DEBUG
  G4cerr << "CompareDouble " << arg1 << " " << opr << " " << arg2
         << " result: " << result << G4endl;
#endif
  return result;
}

References EQ, G4cerr, G4endl, GE, GT, LE, LT, NE, and G4UIcommand::paramERR.

Referenced by G4UIcommand::Eval2().

◆ CompareInt()

G4int G4UIcommand::CompareInt	(	G4int	arg1,
		G4int	op,
		G4int	arg2
	)

privateinherited

Definition at line 1348 of file G4UIcommand.cc.

{
  G4int result = -1;
  G4String opr;
  switch(op)
  {
    case GT:
      result = (arg1 > arg2);
      opr    = ">";
      break;
    case GE:
      result = (arg1 >= arg2);
      opr    = ">=";
      break;
    case LT:
      result = (arg1 < arg2);
      opr    = "<";
      break;
    case LE:
      result = (arg1 <= arg2);
      opr    = "<=";
      break;
    case EQ:
      result = (arg1 == arg2);
      opr    = "==";
      break;
    case NE:
      result = (arg1 != arg2);
      opr    = "!=";
      break;
    default:
      G4cerr << "Parameter range: error at CompareInt" << G4endl;
      paramERR = 1;
  }
#ifdef DEBUG
  G4cerr << "CompareInt " << arg1 << " " << opr << arg2 << " result: " << result
         << G4endl;
#endif
  return result;
}

References EQ, G4cerr, G4endl, GE, GT, LE, LT, NE, and G4UIcommand::paramERR.

Referenced by G4UIcommand::Eval2().

◆ CompareLong()

G4int G4UIcommand::CompareLong	(	G4long	arg1,
		G4int	op,
		G4long	arg2
	)

privateinherited

Definition at line 1390 of file G4UIcommand.cc.

{
  G4int result = -1;
  G4String opr;
  switch(op)
  {
    case GT:
      result = (arg1 > arg2);
      opr    = ">";
      break;
    case GE:
      result = (arg1 >= arg2);
      opr    = ">=";
      break;
    case LT:
      result = (arg1 < arg2);
      opr    = "<";
      break;
    case LE:
      result = (arg1 <= arg2);
      opr    = "<=";
      break;
    case EQ:
      result = (arg1 == arg2);
      opr    = "==";
      break;
    case NE:
      result = (arg1 != arg2);
      opr    = "!=";
      break;
    default:
      G4cerr << "Parameter range: error at CompareInt" << G4endl;
      paramERR = 1;
  }
#ifdef DEBUG
  G4cerr << "CompareInt " << arg1 << " " << opr << arg2 << " result: " << result
         << G4endl;
#endif
  return result;
}

References EQ, G4cerr, G4endl, GE, GT, LE, LT, NE, and G4UIcommand::paramERR.

Referenced by G4UIcommand::Eval2().

◆ ConvertTo3Vector()

G4ThreeVector G4UIcommand::ConvertTo3Vector ( const char * st )

staticinherited

Definition at line 597 of file G4UIcommand.cc.

{
  G4double vx;
  G4double vy;
  G4double vz;
  std::istringstream is(st);
  is >> vx >> vy >> vz;
  return G4ThreeVector(vx, vy, vz);
}

Referenced by G4AnyType::Ref< ValueType >::FromString(), G4UIcmdWith3Vector::GetNew3VectorValue(), G4VisCommandsViewerSet::SetNewValue(), and G4AttCheck::Standard().

◆ ConvertToBool()

G4bool G4UIcommand::ConvertToBool ( const char * st )

staticinherited

Definition at line 545 of file G4UIcommand.cc.

{
  G4String v = G4StrUtil::to_upper_copy(st);
  G4bool vl = false;
  if(v == "Y" || v == "YES" || v == "1" || v == "T" || v == "TRUE")
  {
    vl = true;
  }
  return vl;
}

References G4StrUtil::to_upper_copy().

◆ ConvertToDimensioned3Vector()

G4ThreeVector G4UIcommand::ConvertToDimensioned3Vector ( const char * st )

staticinherited

Definition at line 608 of file G4UIcommand.cc.

{
  G4double vx;
  G4double vy;
  G4double vz;
  char unts[30];
  std::istringstream is(st);
  is >> vx >> vy >> vz >> unts;
  G4String unt = unts;
  G4double uv  = ValueOf(unt);
  return G4ThreeVector(vx * uv, vy * uv, vz * uv);
}

References G4UIcommand::ValueOf().

Referenced by G4UIcmdWith3VectorAndUnit::GetNew3VectorValue(), G4GenericMessenger::SetNewValue(), and G4AttCheck::Standard().

◆ ConvertToDimensionedDouble()

G4double G4UIcommand::ConvertToDimensionedDouble ( const char * st )

staticinherited

Definition at line 584 of file G4UIcommand.cc.

{
  G4double vl;
  char unts[30];
 
  std::istringstream is(st);
  is >> vl >> unts;
  G4String unt = unts;
 
  return (vl * ValueOf(unt));
}

References G4UIcommand::ValueOf().

Referenced by GetNewDoubleValue(), G4TrajectoryDrawerUtils::GetPointsAndTimes(), G4GenericMessenger::SetNewValue(), G4VisCommandViewerInterpolate::SetNewValue(), G4VisCommandsViewerSet::SetNewValue(), and G4AttCheck::Standard().

◆ ConvertToDouble()

G4double G4UIcommand::ConvertToDouble ( const char * st )

staticinherited

Definition at line 575 of file G4UIcommand.cc.

{
  G4double vl;
  std::istringstream is(st);
  is >> vl;
  return vl;
}

Referenced by G4UIcmdWith3VectorAndUnit::DoIt(), DoIt(), G4AnalysisMessengerHelper::GetBinData(), G4UIcmdWithADouble::GetNewDoubleValue(), G4AnalysisMessengerHelper::GetValueData(), G4VisCommandsTouchableSet::SetNewValue(), and G4VisCommandsViewerSet::SetNewValue().

◆ ConvertToInt()

G4int G4UIcommand::ConvertToInt ( const char * st )

staticinherited

Definition at line 557 of file G4UIcommand.cc.

{
  G4int vl;
  std::istringstream is(st);
  is >> vl;
  return vl;
}

◆ ConvertToLongInt()

G4long G4UIcommand::ConvertToLongInt ( const char * st )

staticinherited

Definition at line 566 of file G4UIcommand.cc.

{
  G4long vl;
  std::istringstream is(st);
  is >> vl;
  return vl;
}

Referenced by G4UIcmdWithALongInt::GetNewLongIntValue().

◆ ConvertToString() [1/7]

G4String G4UIcommand::ConvertToString ( G4bool boolVal )

staticinherited

Definition at line 445 of file G4UIcommand.cc.

{
  G4String vl = "0";
  if(boolVal)
    vl = "1";
  return vl;
}

◆ ConvertToString() [2/7]

G4String G4UIcommand::ConvertToString ( G4double doubleValue )

staticinherited

Definition at line 472 of file G4UIcommand.cc.

{
  std::ostringstream os;
  if(G4UImanager::DoublePrecisionStr())
  {
    os << std::setprecision(17) << doubleValue;
  }
  else
  {
    os << doubleValue;
  }
  G4String vl = os.str();
  return vl;
}

References G4UImanager::DoublePrecisionStr().

◆ ConvertToString() [3/7]

G4String G4UIcommand::ConvertToString	(	G4double	doubleValue,
		const char *	unitName
	)

staticinherited

Definition at line 488 of file G4UIcommand.cc.

{
  G4String unt = unitName;
  G4double uv  = ValueOf(unitName);
 
  std::ostringstream os;
  if(G4UImanager::DoublePrecisionStr())
  {
    os << std::setprecision(17) << doubleValue / uv << " " << unitName;
  }
  else
  {
    os << doubleValue / uv << " " << unitName;
  }
  G4String vl = os.str();
  return vl;
}

References G4UImanager::DoublePrecisionStr(), and G4UIcommand::ValueOf().

◆ ConvertToString() [4/7]

G4String G4UIcommand::ConvertToString ( G4int intValue )

staticinherited

Definition at line 454 of file G4UIcommand.cc.

{
  std::ostringstream os;
  os << intValue;
  G4String vl = os.str();
  return vl;
}

◆ ConvertToString() [5/7]

G4String G4UIcommand::ConvertToString ( G4long longValue )

staticinherited

Definition at line 463 of file G4UIcommand.cc.

{
  std::ostringstream os;
  os << longValue;
  G4String vl = os.str();
  return vl;
}

◆ ConvertToString() [6/7]

G4String G4UIcommand::ConvertToString ( G4ThreeVector vec )

staticinherited

Definition at line 508 of file G4UIcommand.cc.

{
  std::ostringstream os;
  if(G4UImanager::DoublePrecisionStr())
  {
    os << std::setprecision(17) << vec.x() << " " << vec.y() << " " << vec.z();
  }
  else
  {
    os << vec.x() << " " << vec.y() << " " << vec.z();
  }
  G4String vl = os.str();
  return vl;
}

References G4UImanager::DoublePrecisionStr(), CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

◆ ConvertToString() [7/7]

G4String G4UIcommand::ConvertToString	(	G4ThreeVector	vec,
		const char *	unitName
	)

staticinherited

Definition at line 524 of file G4UIcommand.cc.

{
  G4String unt = unitName;
  G4double uv  = ValueOf(unitName);
 
  std::ostringstream os;
  if(G4UImanager::DoublePrecisionStr())
  {
    os << std::setprecision(17) << vec.x() / uv << " " << vec.y() / uv << " "
       << vec.z() / uv << " " << unitName;
  }
  else
  {
    os << vec.x() / uv << " " << vec.y() / uv << " " << vec.z() / uv << " "
       << unitName;
  }
  G4String vl = os.str();
  return vl;
}

References G4UImanager::DoublePrecisionStr(), G4UIcommand::ValueOf(), CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

◆ ConvertToStringWithBestUnit()

G4String G4UIcmdWithADoubleAndUnit::ConvertToStringWithBestUnit ( G4double val )

Definition at line 126 of file G4UIcmdWithADoubleAndUnit.cc.

{
  G4UIparameter* unitParam = GetParameter(1);
  G4String canList         = unitParam->GetParameterCandidates();
  G4Tokenizer candidateTokenizer(canList);
  G4String aToken = candidateTokenizer();
  std::ostringstream os;
  os << G4BestUnit(val, CategoryOf(aToken));
 
  G4String st = os.str();
  return st;
}

References G4UIcommand::CategoryOf(), G4BestUnit, G4UIcommand::GetParameter(), and G4UIparameter::GetParameterCandidates().

Referenced by ConvertToStringWithDefaultUnit(), and G4MoleculeShootMessenger::GetCurrentValue().

◆ ConvertToStringWithDefaultUnit()

G4String G4UIcmdWithADoubleAndUnit::ConvertToStringWithDefaultUnit ( G4double val )

Definition at line 140 of file G4UIcmdWithADoubleAndUnit.cc.

{
  G4UIparameter* unitParam = GetParameter(1);
  G4String st;
  if(unitParam->IsOmittable())
  {
    st = ConvertToString(val, unitParam->GetDefaultValue());
  }
  else
  {
    st = ConvertToStringWithBestUnit(val);
  }
  return st;
}

References G4UIcommand::ConvertToString(), ConvertToStringWithBestUnit(), G4UIparameter::GetDefaultValue(), G4UIcommand::GetParameter(), and G4UIparameter::IsOmittable().

◆ DoIt()

G4int G4UIcmdWithADoubleAndUnit::DoIt ( G4String parameterList )

virtual

Reimplemented from G4UIcommand.

Definition at line 52 of file G4UIcmdWithADoubleAndUnit.cc.

{
  std::vector<G4String> token_vector;
  G4Tokenizer tkn(parameterList);
  G4String str;
  while((str = tkn()) != "")
  {
    token_vector.push_back(str);
  }
 
  // convert a value in default unit
  G4String converted_parameter;
  G4String default_unit = GetParameter(1)->GetDefaultValue();
  if(default_unit != "" && token_vector.size() >= 2)
  {
    if(CategoryOf(token_vector[1]) != CategoryOf(default_unit))
    {
      return fParameterOutOfCandidates + 1;
    }
    G4double value_given   = ValueOf(token_vector[1]);
    G4double value_default = ValueOf(default_unit);
    G4double value =
      ConvertToDouble(token_vector[0]) * value_given / value_default;
    // reconstruct parameter list
    converted_parameter += ConvertToString(value);
    converted_parameter += " ";
    converted_parameter += default_unit;
    for(std::size_t i = 2; i < token_vector.size(); ++i)
    {
      converted_parameter += " ";
      converted_parameter += token_vector[i];
    }
  }
  else
  {
    converted_parameter = parameterList;
  }
 
  return G4UIcommand::DoIt(converted_parameter);
}

References G4UIcommand::CategoryOf(), G4UIcommand::ConvertToDouble(), G4UIcommand::ConvertToString(), G4UIcommand::DoIt(), fParameterOutOfCandidates, G4UIparameter::GetDefaultValue(), G4UIcommand::GetParameter(), and G4UIcommand::ValueOf().

◆ EqualityExpression()

yystype G4UIcommand::EqualityExpression ( void )

privateinherited

Definition at line 998 of file G4UIcommand.cc.

{
  yystype arg1, arg2;
  G4int operat;
  yystype result;
#ifdef DEBUG
  G4cerr << " EqualityExpression()" << G4endl;
#endif
  result = RelationalExpression();
  if(token == EQ || token == NE)
  {
    operat      = token;
    token       = Yylex();
    arg1        = result;
    arg2        = RelationalExpression();
    result.I    = Eval2(arg1, operat, arg2);  // semantic action
    result.type = CONSTINT;
#ifdef DEBUG
    G4cerr << " return code of Eval2(): " << result.I << G4endl;
#endif
  }
  else
  {
    if(result.type != CONSTINT && result.type != CONSTDOUBLE)
    {
      G4cerr << "Parameter range: error at EqualityExpression" << G4endl;
      paramERR = 1;
    }
  }
  return result;
}

References G4UItokenNum::CONSTDOUBLE, G4UItokenNum::CONSTINT, EQ, G4UIcommand::Eval2(), G4cerr, G4endl, G4UItokenNum::yystype::I, NE, G4UIcommand::paramERR, G4UIcommand::RelationalExpression(), G4UIcommand::token, G4UItokenNum::yystype::type, and G4UIcommand::Yylex().

Referenced by G4UIcommand::LogicalANDExpression().

◆ Eval2()

G4int G4UIcommand::Eval2	(	yystype	arg1,
		G4int	op,
		yystype	arg2
	)

privateinherited

Definition at line 1181 of file G4UIcommand.cc.

{
  char newValtype;
  if((arg1.type != IDENTIFIER) && (arg2.type != IDENTIFIER))
  {
    G4cerr << commandName << ": meaningless comparison" << G4endl;
    paramERR = 1;
  }
 
  if(arg1.type == IDENTIFIER)
  {
    unsigned i = IndexOf(arg1.S);
    newValtype = toupper(parameter[i]->GetParameterType());
    switch(newValtype)
    {
      case 'I':
        if(arg2.type == CONSTINT)
        {
          return CompareInt(newVal[i].I, op, arg2.I);
          //===================================================================
          // MA - 2018.07.23
        }
        else if(arg2.type == IDENTIFIER)
        {
          unsigned iii     = IndexOf(arg2.S);
          char newValtype2 = toupper(parameter[iii]->GetParameterType());
          if(newValtype2 == 'I')
          {
            return CompareInt(newVal[i].I, op, newVal[iii].I);
          }
          else if(newValtype2 == 'L')
          {
            G4cerr << "Warning : Integer is compared with long int : "
                   << rangeString << G4endl;
            return CompareLong(newVal[i].I, op, newVal[iii].L);
          }
          else if(newValtype2 == 'D')
          {
            G4cerr << "Warning : Integer is compared with double : "
                   << rangeString << G4endl;
            return CompareDouble(newVal[i].I, op, newVal[iii].D);
          }
          //===================================================================
        }
        else
        {
          G4cerr << "integer operand expected for " << rangeString << '.'
                 << G4endl;
        }
        break;
      case 'L':
        if(arg2.type == CONSTINT)
        {
          return CompareLong(newVal[i].L, op, arg2.I);
        }
        else if(arg2.type == CONSTLONG)
        {
          return CompareLong(newVal[i].L, op, arg2.L);
        }
        else if(arg2.type == IDENTIFIER)
        {
          unsigned iii     = IndexOf(arg2.S);
          char newValtype2 = toupper(parameter[iii]->GetParameterType());
          if(newValtype2 == 'I')
          {
            return CompareLong(newVal[i].L, op, newVal[iii].I);
          }
          if(newValtype2 == 'L')
          {
            return CompareLong(newVal[i].L, op, newVal[iii].L);
          }
          else if(newValtype2 == 'D')
          {
            G4cerr << "Warning : Long int is compared with double : "
                   << rangeString << G4endl;
            return CompareDouble(newVal[i].L, op, newVal[iii].D);
          }
          //===================================================================
        }
        else
        {
          G4cerr << "integer operand expected for " << rangeString << '.'
                 << G4endl;
        }
        break;
      case 'D':
        if(arg2.type == CONSTDOUBLE)
        {
          return CompareDouble(newVal[i].D, op, arg2.D);
        }
        else if(arg2.type == CONSTINT)
        {  // integral promotion
          return CompareDouble(newVal[i].D, op, arg2.I);
          //===================================================================
          // MA - 2018.07.23
        }
        else if(arg2.type == CONSTLONG)
        {
          return CompareDouble(newVal[i].D, op, arg2.L);
        }
        else if(arg2.type == IDENTIFIER)
        {
          unsigned iii     = IndexOf(arg2.S);
          char newValtype2 = toupper(parameter[iii]->GetParameterType());
          if(newValtype2 == 'I')
          {
            return CompareDouble(newVal[i].D, op, newVal[iii].I);
          }
          else if(newValtype2 == 'L')
          {
            return CompareDouble(newVal[i].D, op, newVal[iii].L);
          }
          else if(newValtype2 == 'D')
          {
            return CompareDouble(newVal[i].D, op, newVal[iii].D);
          }
          //===================================================================
        }
        break;
      default:;
    }
  }
  if(arg2.type == IDENTIFIER)
  {
    unsigned i = IndexOf(arg2.S);
    newValtype = toupper(parameter[i]->GetParameterType());
    switch(newValtype)
    {
      case 'I':
        if(arg1.type == CONSTINT)
        {
          return CompareInt(arg1.I, op, newVal[i].I);
        }
        else
        {
          G4cerr << "integer operand expected for " << rangeString << '.'
                 << G4endl;
        }
        break;
      case 'L':
        if(arg1.type == CONSTLONG)
        {
          return CompareLong(arg1.L, op, newVal[i].L);
        }
        else
        {
          G4cerr << "long int operand expected for " << rangeString << '.'
                 << G4endl;
        }
        break;
      case 'D':
        if(arg1.type == CONSTDOUBLE)
        {
          return CompareDouble(arg1.D, op, newVal[i].D);
        }
        else if(arg1.type == CONSTINT)
        {  // integral promotion
          return CompareDouble(arg1.I, op, newVal[i].D);
        }
        break;
      default:;
    }
  }
  return 0;
}

References G4UIcommand::commandName, G4UIcommand::CompareDouble(), G4UIcommand::CompareInt(), G4UIcommand::CompareLong(), G4UItokenNum::CONSTDOUBLE, G4UItokenNum::CONSTINT, G4UItokenNum::CONSTLONG, G4UItokenNum::yystype::D, D(), G4cerr, G4endl, G4UItokenNum::yystype::I, G4UItokenNum::IDENTIFIER, G4UIcommand::IndexOf(), L, G4UItokenNum::yystype::L, G4UIcommand::newVal, G4UIcommand::paramERR, G4UIcommand::parameter, G4UIcommand::rangeString, G4UItokenNum::yystype::S, and G4UItokenNum::yystype::type.

Referenced by G4UIcommand::EqualityExpression(), and G4UIcommand::RelationalExpression().

◆ ExpectExponent()

G4int G4UIcommand::ExpectExponent ( const char * str )

privateinherited

Definition at line 726 of file G4UIcommand.cc.

{
  G4int maxExplength;
  if(IsInt(str, maxExplength = 7))
    return 1;
  else
    return 0;
}

References G4UIcommand::IsInt().

Referenced by G4UIcommand::IsDouble().

◆ Expression()

yystype G4UIcommand::Expression ( void )

privateinherited

Definition at line 897 of file G4UIcommand.cc.

{
  yystype result;
#ifdef DEBUG
  G4cerr << " Expression()" << G4endl;
#endif
  result = LogicalORExpression();
  return result;
}

References G4cerr, G4endl, and G4UIcommand::LogicalORExpression().

Referenced by G4UIcommand::PrimaryExpression(), and G4UIcommand::RangeCheck().

◆ Follow()

G4int G4UIcommand::Follow	(	G4int	expect,
		G4int	ifyes,
		G4int	ifno
	)

privateinherited

Definition at line 1581 of file G4UIcommand.cc.

{
  G4int c = G4UIpGetc();
  if(c == expect)
    return ifyes;
  G4UIpUngetc(c);
  return ifno;
}

References G4UIcommand::G4UIpGetc(), and G4UIcommand::G4UIpUngetc().

Referenced by G4UIcommand::Yylex().

◆ G4UIcommandCommonConstructorCode()

void G4UIcommand::G4UIcommandCommonConstructorCode ( const char * theCommandPath )

privateinherited

Definition at line 71 of file G4UIcommand.cc.

{
  commandPath            = theCommandPath;
  commandName            = theCommandPath;
  G4int commandNameIndex = commandName.rfind('/');
  commandName.erase(0, commandNameIndex + 1);
#ifdef G4MULTITHREADED
  if(messenger && messenger->CommandsShouldBeInMaster() &&
     G4Threading::IsWorkerThread())
  {
    toBeBroadcasted = false;
    G4UImanager::GetMasterUIpointer()->AddNewCommand(this);
  }
  else
  {
    G4UImanager::GetUIpointer()->AddNewCommand(this);
  }
#else
  G4UImanager::GetUIpointer()->AddNewCommand(this);
#endif
}

References G4UImanager::AddNewCommand(), G4UIcommand::commandName, G4UIcommand::commandPath, G4UImessenger::CommandsShouldBeInMaster(), G4UImanager::GetMasterUIpointer(), G4UImanager::GetUIpointer(), G4Threading::IsWorkerThread(), G4UIcommand::messenger, and G4UIcommand::toBeBroadcasted.

Referenced by G4UIcommand::G4UIcommand().

◆ G4UIpGetc()

G4int G4UIcommand::G4UIpGetc ( void )

privateinherited

Definition at line 1592 of file G4UIcommand.cc.

{  // emulation of getc()
  G4int length = rangeString.length();
  if(bp < length)
    return rangeString[bp++];
  else
    return EOF;
}

References G4UIcommand::bp, and G4UIcommand::rangeString.

Referenced by G4UIcommand::Follow(), and G4UIcommand::Yylex().

◆ G4UIpUngetc()

G4int G4UIcommand::G4UIpUngetc ( G4int c )

privateinherited

Definition at line 1602 of file G4UIcommand.cc.

{  // emulation of ungetc()
  if(c < 0)
    return -1;
  if(bp > 0 && c == rangeString[bp - 1])
  {
    --bp;
  }
  else
  {
    G4cerr << "G4UIpUngetc() failed." << G4endl;
    G4cerr << "bp=" << bp << " c=" << c << " pR(bp-1)=" << rangeString[bp - 1]
           << G4endl;
    paramERR = 1;
    return -1;
  }
  return 0;
}

References G4UIcommand::bp, G4cerr, G4endl, G4UIcommand::paramERR, and G4UIcommand::rangeString.

Referenced by G4UIcommand::Follow(), and G4UIcommand::Yylex().

◆ GetCommandName()

const G4String & G4UIcommand::GetCommandName ( ) const

inlineinherited

Definition at line 137 of file G4UIcommand.hh.

137{ return commandName; }

References G4UIcommand::commandName.

Referenced by G4UIcommandTree::CompleteCommandPath(), G4UIcommandTree::CreateHTML(), export_G4UIcommand(), G4GenericMessenger::GetCurrentValue(), G4GenericMessenger::SetNewValue(), G4GeneralParticleSourceMessenger::SetNewValue(), G4NtupleMessenger::SetNewValue(), G4OpenGLQtViewer::updateViewerPropertiesTableWidget(), and G4AnalysisMessengerHelper::WarnAboutParameters().

◆ GetCommandPath()

const G4String & G4UIcommand::GetCommandPath ( ) const

inlineinherited

◆ GetCommandType()

CommandType G4UIcommand::GetCommandType ( ) const

inlineinherited

Definition at line 204 of file G4UIcommand.hh.

205 { return commandType; }

G4UIcommand::commandType

CommandType commandType

Definition: G4UIcommand.hh:266

References G4UIcommand::commandType.

◆ GetCurrentValue()

G4String G4UIcommand::GetCurrentValue ( )

inherited

Definition at line 282 of file G4UIcommand.cc.

{
  return messenger->GetCurrentValue(this);
}

References G4UImessenger::GetCurrentValue(), and G4UIcommand::messenger.

Referenced by export_G4UIcommand(), and G4UImanager::GetCurrentValues().

◆ GetFailureDescription()

const G4String & G4UIcommand::GetFailureDescription ( )

inlineinherited

Definition at line 190 of file G4UIcommand.hh.

190{return failureDescription;}

References G4UIcommand::failureDescription.

Referenced by G4UImanager::ApplyCommand().

◆ GetGuidanceEntries()

std::size_t G4UIcommand::GetGuidanceEntries ( ) const

inlineinherited

Definition at line 128 of file G4UIcommand.hh.

    {
      return commandGuidance.size();
    }

References G4UIcommand::commandGuidance.

Referenced by G4VVisCommand::CopyGuidanceFrom(), G4UIQt::CreateCompleterModel(), G4UIcommandTree::CreateHTML(), G4UIQt::CreateVisCommandGroupAndToolBox(), export_G4UIcommand(), G4UIQt::GetCommandList(), G4GenericMessenger::Command::SetUnit(), G4UIQt::updateHelpArea(), and G4OpenGLQtViewer::updateViewerPropertiesTableWidget().

◆ GetGuidanceLine()

const G4String & G4UIcommand::GetGuidanceLine ( G4int i ) const

inlineinherited

Definition at line 132 of file G4UIcommand.hh.

    {
      return commandGuidance[i];
    }

References G4UIcommand::commandGuidance.

Referenced by G4VVisCommand::CopyGuidanceFrom(), G4UIQt::CreateCompleterModel(), G4UIcommandTree::CreateHTML(), G4UIQt::CreateVisCommandGroupAndToolBox(), export_G4UIcommand(), G4UIQt::GetCommandList(), G4UIWin32::GetHelpTreeToolTips(), G4GenericMessenger::Command::SetUnit(), G4UIQt::updateHelpArea(), and G4OpenGLQtViewer::updateViewerPropertiesTableWidget().

◆ GetMessenger()

G4UImessenger * G4UIcommand::GetMessenger ( ) const

inlineinherited

Definition at line 144 of file G4UIcommand.hh.

144{ return messenger; }

References G4UIcommand::messenger.

Referenced by G4GenericMessenger::Command::SetUnit().

◆ GetNewDoubleRawValue()

G4double G4UIcmdWithADoubleAndUnit::GetNewDoubleRawValue ( const char * paramString )

static

Definition at line 100 of file G4UIcmdWithADoubleAndUnit.cc.

{
  G4double vl;
  char unts[30];
 
  std::istringstream is(paramString);
  is >> vl >> unts;
 
  return vl;
}

◆ GetNewDoubleValue()

G4double G4UIcmdWithADoubleAndUnit::GetNewDoubleValue ( const char * paramString )

static

Definition at line 94 of file G4UIcmdWithADoubleAndUnit.cc.

{
  return ConvertToDimensionedDouble(paramString);
}

References G4UIcommand::ConvertToDimensionedDouble().

◆ GetNewUnitValue()

G4double G4UIcmdWithADoubleAndUnit::GetNewUnitValue ( const char * paramString )

static

Definition at line 113 of file G4UIcmdWithADoubleAndUnit.cc.

{
  G4double vl;
  char unts[30];
 
  std::istringstream is(paramString);
  is >> vl >> unts;
  G4String unt = unts;
 
  return ValueOf(unt);
}

References G4UIcommand::ValueOf().

Referenced by G4GeometryMessenger::SetNewValue().

◆ GetParameter()

G4UIparameter * G4UIcommand::GetParameter ( G4int i ) const

inlineinherited

Definition at line 139 of file G4UIcommand.hh.

139{ return parameter[i]; }

References G4UIcommand::parameter.

◆ GetParameterEntries()

std::size_t G4UIcommand::GetParameterEntries ( ) const

inlineinherited

Definition at line 138 of file G4UIcommand.hh.

138{ return parameter.size(); }

References G4UIcommand::parameter.

◆ GetRange()

const G4String & G4UIcommand::GetRange ( ) const

inlineinherited

Definition at line 127 of file G4UIcommand.hh.

127{ return rangeString; }

References G4UIcommand::rangeString.

Referenced by G4UIQt::CreateCompleterModel(), G4UIcommandTree::CreateHTML(), export_G4UIcommand(), G4UIQt::GetCommandList(), G4GenericMessenger::Command::SetUnit(), and G4UIQt::updateHelpArea().

◆ GetStateList()

std::vector< G4ApplicationState > * G4UIcommand::GetStateList ( )

inlineinherited

Definition at line 140 of file G4UIcommand.hh.

    {
      return &availabelStateList;
    }

References G4UIcommand::availabelStateList.

Referenced by G4UIcommandTree::CreateHTML(), and pyG4UIcommand::f_GetStateList().

◆ GetTitle()

const G4String G4UIcommand::GetTitle ( ) const

inlineinherited

Definition at line 165 of file G4UIcommand.hh.

    {
      return (commandGuidance.size() == 0)
             ? G4String("...Title not available...")
             : commandGuidance[0];
    }

References G4UIcommand::commandGuidance.

Referenced by export_G4UIcommand(), and G4UIcommandTree::GetTitle().

◆ IfCommandFailed()

G4int G4UIcommand::IfCommandFailed ( )

inlineinherited

Definition at line 189 of file G4UIcommand.hh.

189{ return commandFailureCode; }

References G4UIcommand::commandFailureCode.

Referenced by G4UImanager::ApplyCommand().

◆ IndexOf()

unsigned G4UIcommand::IndexOf ( const char * nam )

privateinherited

Definition at line 1474 of file G4UIcommand.cc.

{
  unsigned i;
  G4String pname;
  for(i = 0; i < parameter.size(); ++i)
  {
    pname = parameter[i]->GetParameterName();
    if(pname == nam)
    {
      return i;
    }
  }
  paramERR = 1;
  G4cerr << "parameter name:" << nam << " not found." << G4endl;
  return 0;
}

References G4cerr, G4endl, G4UIcommand::paramERR, G4UIcommand::parameter, and eplot::pname.

Referenced by G4UIcommand::Eval2().

◆ IsAvailable()

G4bool G4UIcommand::IsAvailable ( )

inherited

Definition at line 343 of file G4UIcommand.cc.

{
  G4bool av = false;
  G4ApplicationState currentState =
    G4StateManager::GetStateManager()->GetCurrentState();
 
  G4int nState = availabelStateList.size();
  for(G4int i = 0; i < nState; ++i)
  {
    if(availabelStateList[i] == currentState)
    {
      av = true;
      break;
    }
  }
 
  return av;
}

References G4UIcommand::availabelStateList, G4StateManager::GetCurrentState(), and G4StateManager::GetStateManager().

Referenced by G4UImanager::ApplyCommand(), and export_G4UIcommand().

◆ IsDouble()

G4int G4UIcommand::IsDouble ( const char * str )

privateinherited

Definition at line 736 of file G4UIcommand.cc.

{
  const char* p = buf;
  switch(*p)
  {
    case '+':
    case '-':
      ++p;
      if(isdigit(*p))
      {
        while(isdigit((G4int)(*p)))
        {
          ++p;
        }
        switch(*p)
        {
          case '\0':
            return 1;
            // break;
          case 'E':
          case 'e':
            return ExpectExponent(++p);
            // break;
          case '.':
            ++p;
            if(*p == '\0')
              return 1;
            if(*p == 'e' || *p == 'E')
              return ExpectExponent(++p);
            if(isdigit(*p))
            {
              while(isdigit((G4int)(*p)))
              {
                ++p;
              }
              if(*p == '\0')
                return 1;
              if(*p == 'e' || *p == 'E')
                return ExpectExponent(++p);
            }
            else
              return 0;
            break;
          default:
            return 0;
        }
      }
      if(*p == '.')
      {
        ++p;
        if(isdigit(*p))
        {
          while(isdigit((G4int)(*p)))
          {
            ++p;
          }
          if(*p == '\0')
            return 1;
          if(*p == 'e' || *p == 'E')
            return ExpectExponent(++p);
        }
      }
      break;
    case '.':
      ++p;
      if(isdigit(*p))
      {
        while(isdigit((G4int)(*p)))
        {
          ++p;
        }
        if(*p == '\0')
          return 1;
        if(*p == 'e' || *p == 'E')
          return ExpectExponent(++p);
      }
      break;
    default:  // digit is expected
      if(isdigit(*p))
      {
        while(isdigit((G4int)(*p)))
        {
          ++p;
        }
        if(*p == '\0')
          return 1;
        if(*p == 'e' || *p == 'E')
          return ExpectExponent(++p);
        if(*p == '.')
        {
          ++p;
          if(*p == '\0')
            return 1;
          if(*p == 'e' || *p == 'E')
            return ExpectExponent(++p);
          if(isdigit(*p))
          {
            while(isdigit((G4int)(*p)))
            {
              ++p;
            }
            if(*p == '\0')
              return 1;
            if(*p == 'e' || *p == 'E')
              return ExpectExponent(++p);
          }
        }
      }
  }
  return 0;
}

References G4UIcommand::ExpectExponent().

Referenced by G4UIcommand::TypeCheck(), and G4UIcommand::Yylex().

◆ IsInt()

G4int G4UIcommand::IsInt	(	const char *	str,
		short	maxLength
	)

privateinherited

Definition at line 689 of file G4UIcommand.cc.

{
  const char* p = buf;
  G4int length  = 0;
  if(*p == '+' || *p == '-')
  {
    ++p;
  }
  if(isdigit((G4int)(*p)))
  {
    while(isdigit((G4int)(*p)))
    {
      ++p;
      ++length;
    }
    if(*p == '\0')
    {
      if(length > maxDigits)
      {
        G4cerr << "digit length exceeds" << G4endl;
        return 0;
      }
      return 1;
    }
    else
    {
      // G4cerr <<"illegal character after int:"<<buf<<G4endl;
    }
  }
  else
  {
    // G4cerr <<"illegal int:"<<buf<<G4endl;
  }
  return 0;
}

References G4cerr, and G4endl.

Referenced by G4UIcommand::ExpectExponent(), G4UIcommand::TypeCheck(), and G4UIcommand::Yylex().

◆ IsParameter()

unsigned G4UIcommand::IsParameter ( const char * nam )

privateinherited

Definition at line 1492 of file G4UIcommand.cc.

{
  G4String pname;
  for(unsigned i = 0; i < parameter.size(); ++i)
  {
    pname = parameter[i]->GetParameterName();
    if(pname == nam)
      return 1;
  }
  return 0;
}

References G4UIcommand::parameter, and eplot::pname.

Referenced by G4UIcommand::Yylex().

◆ IsWorkerThreadOnly()

G4bool G4UIcommand::IsWorkerThreadOnly ( ) const

inlineinherited

Definition at line 177 of file G4UIcommand.hh.

177{ return workerThreadOnly; }

G4UIcommand::workerThreadOnly

G4bool workerThreadOnly

Definition: G4UIcommand.hh:221

References G4UIcommand::workerThreadOnly.

Referenced by G4UIcommandTree::RemoveCommand().

◆ List()

void G4UIcommand::List ( )

virtualinherited

Definition at line 410 of file G4UIcommand.cc.

{
  G4cout << G4endl;
  G4cout << G4endl;
  if(commandPath.back() != '/')
  {
    G4cout << "Command " << commandPath << G4endl;
  }
  if(workerThreadOnly)
  {
    G4cout << "    ---- available only in worker thread" << G4endl;
  }
  G4cout << "Guidance :" << G4endl;
  G4int n_guidanceEntry = commandGuidance.size();
  for(G4int i_thGuidance = 0; i_thGuidance < n_guidanceEntry; ++i_thGuidance)
  {
    G4cout << commandGuidance[i_thGuidance] << G4endl;
  }
  if(!rangeString.empty())
  {
    G4cout << " Range of parameters : " << rangeString << G4endl;
  }
  G4int n_parameterEntry = parameter.size();
  if(n_parameterEntry > 0)
  {
    for(G4int i_thParameter = 0; i_thParameter < n_parameterEntry;
        ++i_thParameter)
    {
      parameter[i_thParameter]->List();
    }
  }
  G4cout << G4endl;
}

References G4UIcommand::commandGuidance, G4UIcommand::commandPath, G4cout, G4endl, G4UIcommand::parameter, G4UIcommand::rangeString, and G4UIcommand::workerThreadOnly.

Referenced by export_G4UIcommand(), G4UIcommandTree::ListCurrent(), G4UIcommandTree::ListCurrentWithNum(), and G4VBasicShell::TerminalHelp().

◆ LogicalANDExpression()

yystype G4UIcommand::LogicalANDExpression ( void )

privateinherited

Definition at line 953 of file G4UIcommand.cc.

{
  yystype result;
  yystype p;
  p = EqualityExpression();
  if(token != LOGICALAND)
    return p;
  if(p.type == CONSTSTRING || p.type == IDENTIFIER)
  {
    G4cerr << "Parameter range: illegal type at '&&'" << G4endl;
    paramERR = 1;
  }
  result.I = p.I;
  while(token == LOGICALAND)
  {
    token = Yylex();
    p     = EqualityExpression();
    if(p.type == CONSTSTRING || p.type == IDENTIFIER)
    {
      G4cerr << "Parameter range: illegal type at '&&'" << G4endl;
      paramERR = 1;
    }
    switch(p.type)
    {
      case CONSTINT:
        result.I *= p.I;
        result.type = CONSTINT;
        break;
      case CONSTLONG:
        result.I *= (p.L != 0L);
        result.type = CONSTINT;
        break;
      case CONSTDOUBLE:
        result.I *= (p.D != 0.0);
        result.type = CONSTINT;
        break;
      default:
        G4cerr << "Parameter range: unknown type." << G4endl;
        paramERR = 1;
    }
  }
  return result;
}

References G4UItokenNum::CONSTDOUBLE, G4UItokenNum::CONSTINT, G4UItokenNum::CONSTLONG, G4UItokenNum::CONSTSTRING, G4UItokenNum::yystype::D, G4UIcommand::EqualityExpression(), G4cerr, G4endl, G4UItokenNum::yystype::I, G4UItokenNum::IDENTIFIER, L, G4UItokenNum::yystype::L, G4UItokenNum::LOGICALAND, G4UIcommand::paramERR, G4UIcommand::token, G4UItokenNum::yystype::type, and G4UIcommand::Yylex().

Referenced by G4UIcommand::LogicalORExpression().

◆ LogicalORExpression()

yystype G4UIcommand::LogicalORExpression ( void )

privateinherited

Definition at line 908 of file G4UIcommand.cc.

{
  yystype result;
  yystype p;
  p = LogicalANDExpression();
  if(token != LOGICALOR)
    return p;
  if(p.type == CONSTSTRING || p.type == IDENTIFIER)
  {
    G4cerr << "Parameter range: illegal type at '||'" << G4endl;
    paramERR = 1;
  }
  result.I = p.I;
  while(token == LOGICALOR)
  {
    token = Yylex();
    p     = LogicalANDExpression();
    if(p.type == CONSTSTRING || p.type == IDENTIFIER)
    {
      G4cerr << "Parameter range: illegal type at '||'" << G4endl;
      paramERR = 1;
    }
    switch(p.type)
    {
      case CONSTINT:
        result.I += p.I;
        result.type = CONSTINT;
        break;
      case CONSTLONG:
        result.I += (p.L != 0L);
        result.type = CONSTINT;
        break;
      case CONSTDOUBLE:
        result.I += (p.D != 0.0);
        result.type = CONSTINT;
        break;
      default:
        G4cerr << "Parameter range: unknown type" << G4endl;
        paramERR = 1;
    }
  }
  return result;
}

References G4UItokenNum::CONSTDOUBLE, G4UItokenNum::CONSTINT, G4UItokenNum::CONSTLONG, G4UItokenNum::CONSTSTRING, G4UItokenNum::yystype::D, G4cerr, G4endl, G4UItokenNum::yystype::I, G4UItokenNum::IDENTIFIER, L, G4UItokenNum::yystype::L, G4UIcommand::LogicalANDExpression(), G4UItokenNum::LOGICALOR, G4UIcommand::paramERR, G4UIcommand::token, G4UItokenNum::yystype::type, and G4UIcommand::Yylex().

Referenced by G4UIcommand::Expression().

◆ MultiplicativeExpression()

yystype G4UIcommand::MultiplicativeExpression ( void )

privateinherited

Definition at line 1076 of file G4UIcommand.cc.

{
  yystype result;
  result = UnaryExpression();
  if(token != '*' && token != '/' && token != '%')
    return result;
  G4cerr << "Parameter range: operator " << (char) token << " is not supported."
         << G4endl;
  paramERR = 1;
  return result;
}

References G4cerr, G4endl, G4UIcommand::paramERR, G4UIcommand::token, and G4UIcommand::UnaryExpression().

Referenced by G4UIcommand::AdditiveExpression().

◆ operator!=()

G4bool G4UIcommand::operator!= ( const G4UIcommand & right ) const

inherited

Definition at line 145 of file G4UIcommand.cc.

{
  return (commandPath != right.GetCommandPath());
}

References G4UIcommand::commandPath, and G4UIcommand::GetCommandPath().

◆ operator==()

G4bool G4UIcommand::operator== ( const G4UIcommand & right ) const

inherited

Definition at line 139 of file G4UIcommand.cc.

{
  return (commandPath == right.GetCommandPath());
}

References G4UIcommand::commandPath, and G4UIcommand::GetCommandPath().

◆ PrimaryExpression()

yystype G4UIcommand::PrimaryExpression ( void )

privateinherited

Definition at line 1135 of file G4UIcommand.cc.

{
  yystype result;
#ifdef DEBUG
  G4cerr << " primary_exp" << G4endl;
#endif
  switch(token)
  {
    case IDENTIFIER:
      result.S    = yylval.S;
      result.type = token;
      token       = Yylex();
      break;
    case CONSTINT:
      result.I    = yylval.I;
      result.type = token;
      token       = Yylex();
      break;
    case CONSTLONG:
      result.L    = yylval.L;
      result.type = token;
      token       = Yylex();
      break;
    case CONSTDOUBLE:
      result.D    = yylval.D;
      result.type = token;
      token       = Yylex();
      break;
    case '(':
      token  = Yylex();
      result = Expression();
      if(token != ')')
      {
        G4cerr << " ')' expected" << G4endl;
        paramERR = 1;
      }
      token = Yylex();
      break;
    default:
      return result;
  }
  return result;  // never executed
}

References G4UItokenNum::CONSTDOUBLE, G4UItokenNum::CONSTINT, G4UItokenNum::CONSTLONG, G4UItokenNum::yystype::D, G4UIcommand::Expression(), G4cerr, G4endl, G4UItokenNum::yystype::I, G4UItokenNum::IDENTIFIER, G4UItokenNum::yystype::L, G4UIcommand::paramERR, G4UItokenNum::yystype::S, G4UIcommand::token, G4UItokenNum::yystype::type, G4UIcommand::Yylex(), and G4UIcommand::yylval.

Referenced by G4UIcommand::UnaryExpression().

◆ RangeCheck()

G4int G4UIcommand::RangeCheck ( const char * t )

privateinherited

Definition at line 849 of file G4UIcommand.cc.

{
  yystype result;
  char type;
  bp = 0;  // reset buffer pointer for G4UIpGetc()
  std::istringstream is(t);
  for(unsigned i = 0; i < parameter.size(); ++i)
  {
    type = toupper(parameter[i]->GetParameterType());
    switch(type)
    {
      case 'D':
        is >> newVal[i].D;
        break;
      case 'I':
        is >> newVal[i].I;
        break;
      case 'L':
        is >> newVal[i].L;
        break;
      case 'S':
        is >> newVal[i].S;
        break;
      case 'B':
        is >> newVal[i].C;
        break;
      default:;
    }
  }
  // PrintToken();          // Print tokens (consumes all tokens)
  token  = Yylex();
  result = Expression();
 
  if(paramERR == 1)
    return 0;
  if(result.type != CONSTINT)
  {
    G4cerr << "Illegal Expression in parameter range." << G4endl;
    return 0;
  }
  if(result.I)
    return 1;
  G4cerr << "parameter out of range: " << rangeString << G4endl;
  return 0;
}

References G4UIcommand::bp, G4UItokenNum::CONSTINT, G4UIcommand::Expression(), G4cerr, G4endl, G4UItokenNum::yystype::I, G4UIcommand::newVal, G4UIcommand::paramERR, G4UIcommand::parameter, G4UIcommand::rangeString, G4UIcommand::token, G4UItokenNum::yystype::type, and G4UIcommand::Yylex().

Referenced by G4UIcommand::CheckNewValue().

◆ RelationalExpression()

yystype G4UIcommand::RelationalExpression ( void )

privateinherited

Definition at line 1031 of file G4UIcommand.cc.

{
  yystype arg1, arg2;
  G4int operat;
  yystype result;
#ifdef DEBUG
  G4cerr << " RelationalExpression()" << G4endl;
#endif
 
  arg1 = AdditiveExpression();
  if(token == GT || token == GE || token == LT || token == LE)
  {
    operat      = token;
    token       = Yylex();
    arg2        = AdditiveExpression();
    result.I    = Eval2(arg1, operat, arg2);  // semantic action
    result.type = CONSTINT;
#ifdef DEBUG
    G4cerr << " return code of Eval2(): " << result.I << G4endl;
#endif
  }
  else
  {
    result = arg1;
  }
#ifdef DEBUG
  G4cerr << " return RelationalExpression()" << G4endl;
#endif
  return result;
}

References G4UIcommand::AdditiveExpression(), G4UItokenNum::CONSTINT, G4UIcommand::Eval2(), G4cerr, G4endl, GE, GT, G4UItokenNum::yystype::I, LE, LT, G4UIcommand::token, G4UItokenNum::yystype::type, and G4UIcommand::Yylex().

Referenced by G4UIcommand::EqualityExpression().

◆ ResetFailure()

void G4UIcommand::ResetFailure ( )

inlineinherited

Definition at line 191 of file G4UIcommand.hh.

    {
      commandFailureCode = 0;
      failureDescription = "";
    }

References G4UIcommand::commandFailureCode, and G4UIcommand::failureDescription.

Referenced by G4UImanager::ApplyCommand(), and G4UIcontrolMessenger::SetNewValue().

◆ SetCommandType()

void G4UIcommand::SetCommandType ( CommandType typ )

inherited

Definition at line 94 of file G4UIcommand.cc.

{
  if(messenger==nullptr)
  {  // this must be a directory
    if(typ != CmdDirectory)
    {
      G4ExceptionDescription ed;
      ed << "A UI command <" << commandPath
         << "> is defined without vaild messenger.";
      G4Exception("G4UIcommand::SetCommandType","UI2031",
         FatalException,ed);
    }
    else if(commandPath.back() != '/')
    {
      G4ExceptionDescription ed;
      ed << "G4UIcommand Warning : \n" 
         << "  <" << commandPath << "> must be a directory." 
         << "  '/' is appended.";
      G4Exception("G4UIcommand::SetCommandType","UI2032",
         JustWarning,ed);
      commandPath += "/";
    }
  }
  commandType = typ;
}

References G4UIcommand::CmdDirectory, G4UIcommand::commandPath, G4UIcommand::commandType, FatalException, G4Exception(), JustWarning, G4UIcommand::messenger, and pyG4ProcessManager::typ.

Referenced by G4UIcmdWith3Vector::G4UIcmdWith3Vector(), G4UIcmdWith3VectorAndUnit::G4UIcmdWith3VectorAndUnit(), G4UIcmdWithABool::G4UIcmdWithABool(), G4UIcmdWithADouble::G4UIcmdWithADouble(), G4UIcmdWithADoubleAndUnit(), G4UIcmdWithALongInt::G4UIcmdWithALongInt(), G4UIcmdWithAnInteger::G4UIcmdWithAnInteger(), G4UIcmdWithAString::G4UIcmdWithAString(), G4UIcmdWithoutParameter::G4UIcmdWithoutParameter(), and G4UIdirectory::G4UIdirectory().

◆ SetDefaultSortFlag()

void G4UIcommand::SetDefaultSortFlag ( G4bool val )

inlineinherited

Definition at line 208 of file G4UIcommand.hh.

209 { ifSort = val; }

G4UIcommand::ifSort

G4bool ifSort

Definition: G4UIcommand.hh:226

References G4UIcommand::ifSort.

Referenced by G4UIcommandTree::AddNewCommand().

◆ SetDefaultUnit()

void G4UIcmdWithADoubleAndUnit::SetDefaultUnit ( const char * defUnit )

Definition at line 188 of file G4UIcmdWithADoubleAndUnit.cc.

{
  G4UIparameter* untParam = GetParameter(1);
  untParam->SetOmittable(true);
  untParam->SetDefaultValue(defUnit);
  SetUnitCategory(CategoryOf(defUnit));
}

References G4UIcommand::CategoryOf(), G4UIcommand::GetParameter(), G4UIparameter::SetDefaultValue(), G4UIparameter::SetOmittable(), and SetUnitCategory().

Referenced by G4ErrorMessenger::G4ErrorMessenger(), G4GeneralParticleSourceMessenger::G4GeneralParticleSourceMessenger(), G4GeometryMessenger::G4GeometryMessenger(), G4NuclideTableMessenger::G4NuclideTableMessenger(), G4ParticleGunMessenger::G4ParticleGunMessenger(), G4ParticlePropertyMessenger::G4ParticlePropertyMessenger(), G4ProductionCutsTableMessenger::G4ProductionCutsTableMessenger(), G4RTMessenger::G4RTMessenger(), G4SchedulerMessenger::G4SchedulerMessenger(), G4ScoringMessenger::G4ScoringMessenger(), G4UserPhysicsListMessenger::G4UserPhysicsListMessenger(), GFlashShowerModelMessenger::GFlashShowerModelMessenger(), and G4GenericMessenger::Command::SetUnit().

◆ SetDefaultValue()

void G4UIcmdWithADoubleAndUnit::SetDefaultValue ( G4double defVal )

Definition at line 167 of file G4UIcmdWithADoubleAndUnit.cc.

{
  G4UIparameter* theParam = GetParameter(0);
  theParam->SetDefaultValue(defVal);
}

References G4UIcommand::GetParameter(), and G4UIparameter::SetDefaultValue().

Referenced by G4GeneralParticleSourceMessenger::G4GeneralParticleSourceMessenger(), G4GeometryMessenger::G4GeometryMessenger(), G4HadronicEPTestMessenger::G4HadronicEPTestMessenger(), G4INCLXXInterfaceMessenger::G4INCLXXInterfaceMessenger(), G4NuclideTableMessenger::G4NuclideTableMessenger(), G4ParticlePropertyMessenger::G4ParticlePropertyMessenger(), G4ProductionCutsTableMessenger::G4ProductionCutsTableMessenger(), G4RTMessenger::G4RTMessenger(), G4SchedulerMessenger::G4SchedulerMessenger(), and G4UserPhysicsListMessenger::G4UserPhysicsListMessenger().

◆ SetGuidance()

void G4UIcommand::SetGuidance ( const char * aGuidance )

inlineinherited

Definition at line 156 of file G4UIcommand.hh.

    {
      commandGuidance.push_back(G4String(aGuidance));
    }

References G4UIcommand::commandGuidance.

◆ SetParameter()

void G4UIcommand::SetParameter ( G4UIparameter *const newParameter )

inlineinherited

Definition at line 146 of file G4UIcommand.hh.

    {
      parameter.push_back(newParameter);
      newVal.resize(parameter.size());
    }

References G4UIcommand::newVal, and G4UIcommand::parameter.

◆ SetParameterName()

void G4UIcmdWithADoubleAndUnit::SetParameterName	(	const char *	theName,
		G4bool	omittable,
		G4bool	currentAsDefault = `false`
	)

Definition at line 156 of file G4UIcmdWithADoubleAndUnit.cc.

{
  G4UIparameter* theParam = GetParameter(0);
  theParam->SetParameterName(theName);
  theParam->SetOmittable(omittable);
  theParam->SetCurrentAsDefault(currentAsDefault);
}

References G4UIcommand::GetParameter(), G4UIparameter::SetCurrentAsDefault(), G4UIparameter::SetOmittable(), and G4UIparameter::SetParameterName().

Referenced by ExN03DetectorMessenger::ExN03DetectorMessenger(), G4AdjointSimMessenger::G4AdjointSimMessenger(), G4EmMessenger::G4EmMessenger(), G4EmParametersMessenger::G4EmParametersMessenger(), G4GeneralParticleSourceMessenger::G4GeneralParticleSourceMessenger(), G4GeometryMessenger::G4GeometryMessenger(), G4HadronicEPTestMessenger::G4HadronicEPTestMessenger(), G4HadronicParametersMessenger::G4HadronicParametersMessenger(), G4INCLXXInterfaceMessenger::G4INCLXXInterfaceMessenger(), G4ModelCmdApplyDoubleAndUnit< M >::G4ModelCmdApplyDoubleAndUnit(), G4NeutronKillerMessenger::G4NeutronKillerMessenger(), G4NuclideTableMessenger::G4NuclideTableMessenger(), G4OpenGLXmViewerMessenger::G4OpenGLXmViewerMessenger(), G4ParticleGunMessenger::G4ParticleGunMessenger(), G4ParticlePropertyMessenger::G4ParticlePropertyMessenger(), G4ProductionCutsTableMessenger::G4ProductionCutsTableMessenger(), G4RadioactivationMessenger::G4RadioactivationMessenger(), G4RadioactiveDecayMessenger::G4RadioactiveDecayMessenger(), G4RTMessenger::G4RTMessenger(), G4ScoringMessenger::G4ScoringMessenger(), G4UserPhysicsListMessenger::G4UserPhysicsListMessenger(), GFlashShowerModelMessenger::GFlashShowerModelMessenger(), PhysicsListMessenger::PhysicsListMessenger(), and G4GenericMessenger::Command::SetUnit().

◆ SetRange()

void G4UIcommand::SetRange ( const char * rs )

inlineinherited

Definition at line 120 of file G4UIcommand.hh.

120{ rangeString = rs; }

References G4UIcommand::rangeString.

Referenced by ExN03DetectorMessenger::ExN03DetectorMessenger(), G4DecayTableMessenger::G4DecayTableMessenger(), G4EmParametersMessenger::G4EmParametersMessenger(), G4EvManMessenger::G4EvManMessenger(), G4GeneralParticleSourceMessenger::G4GeneralParticleSourceMessenger(), G4GeometryMessenger::G4GeometryMessenger(), G4GlobalMagFieldMessenger::G4GlobalMagFieldMessenger(), G4HadronicEPTestMessenger::G4HadronicEPTestMessenger(), G4HadronicParametersMessenger::G4HadronicParametersMessenger(), G4HepRepMessenger::G4HepRepMessenger(), G4INCLXXInterfaceMessenger::G4INCLXXInterfaceMessenger(), G4NistMessenger::G4NistMessenger(), G4NuclideTableMessenger::G4NuclideTableMessenger(), G4OpenGLViewerMessenger::G4OpenGLViewerMessenger(), G4OpenInventorXtExaminerViewerMessenger::G4OpenInventorXtExaminerViewerMessenger(), G4OpticalParametersMessenger::G4OpticalParametersMessenger(), G4ParticleGunMessenger::G4ParticleGunMessenger(), G4ParticleHPMessenger::G4ParticleHPMessenger(), G4ParticleMessenger::G4ParticleMessenger(), G4ParticlePropertyMessenger::G4ParticlePropertyMessenger(), G4PersistencyCenterMessenger::G4PersistencyCenterMessenger(), G4PolarizationMessenger::G4PolarizationMessenger(), G4ProcessManagerMessenger::G4ProcessManagerMessenger(), G4ProcessTableMessenger::G4ProcessTableMessenger(), G4ProductionCutsTableMessenger::G4ProductionCutsTableMessenger(), G4RadioactivationMessenger::G4RadioactivationMessenger(), G4RadioactiveDecayMessenger::G4RadioactiveDecayMessenger(), G4RTMessenger::G4RTMessenger(), G4RunMessenger::G4RunMessenger(), G4SchedulerMessenger::G4SchedulerMessenger(), G4ScoringMessenger::G4ScoringMessenger(), G4StackingMessenger::G4StackingMessenger(), G4tgrMessenger::G4tgrMessenger(), G4TrackingMessenger::G4TrackingMessenger(), G4UIcontrolMessenger::G4UIcontrolMessenger(), G4UserPhysicsListMessenger::G4UserPhysicsListMessenger(), G4VisCommandSetArrow3DLineSegmentsPerCircle::G4VisCommandSetArrow3DLineSegmentsPerCircle(), G4VisCommandSetLineWidth::G4VisCommandSetLineWidth(), G4VisCommandSetTextSize::G4VisCommandSetTextSize(), G4VisCommandsViewerSet::G4VisCommandsViewerSet(), PhysicsListMessenger::PhysicsListMessenger(), G4GenericMessenger::Command::SetRange(), and G4GenericMessenger::Command::SetUnit().

◆ SetToBeBroadcasted()

void G4UIcommand::SetToBeBroadcasted ( G4bool val )

inlineinherited

Definition at line 172 of file G4UIcommand.hh.

172{ toBeBroadcasted = val; }

References G4UIcommand::toBeBroadcasted.

Referenced by G4UIcommandTree::AddNewCommand(), G4EmExtraParametersMessenger::G4EmExtraParametersMessenger(), G4EmLowEParametersMessenger::G4EmLowEParametersMessenger(), G4EmParametersMessenger::G4EmParametersMessenger(), G4GDMLMessenger::G4GDMLMessenger(), G4ParticleMessenger::G4ParticleMessenger(), G4RunMessenger::G4RunMessenger(), G4ScoringMessenger::G4ScoringMessenger(), G4UIcontrolMessenger::G4UIcontrolMessenger(), G4UserPhysicsListMessenger::G4UserPhysicsListMessenger(), and G4GenericMessenger::Command::SetToBeBroadcasted().

◆ SetToBeFlushed()

void G4UIcommand::SetToBeFlushed ( G4bool val )

inlineinherited

Definition at line 174 of file G4UIcommand.hh.

174{ toBeFlushed = val; }

G4UIcommand::toBeFlushed

G4bool toBeFlushed

Definition: G4UIcommand.hh:220

References G4UIcommand::toBeFlushed.

Referenced by G4GenericMessenger::Command::SetToBeFlushed().

◆ SetUnitCandidates()

void G4UIcmdWithADoubleAndUnit::SetUnitCandidates ( const char * candidateList )

Definition at line 180 of file G4UIcmdWithADoubleAndUnit.cc.

{
  G4UIparameter* untParam = GetParameter(1);
  G4String canList        = candidateList;
  untParam->SetParameterCandidates(canList);
}

References G4UIcommand::GetParameter(), and G4UIparameter::SetParameterCandidates().

Referenced by SetUnitCategory().

◆ SetUnitCategory()

void G4UIcmdWithADoubleAndUnit::SetUnitCategory ( const char * unitCategory )

Definition at line 174 of file G4UIcmdWithADoubleAndUnit.cc.

{
  SetUnitCandidates(UnitsList(unitCategory));
}

References SetUnitCandidates(), and G4UIcommand::UnitsList().

Referenced by ExN03DetectorMessenger::ExN03DetectorMessenger(), G4AdjointSimMessenger::G4AdjointSimMessenger(), G4EmMessenger::G4EmMessenger(), G4EmParametersMessenger::G4EmParametersMessenger(), G4GeometryMessenger::G4GeometryMessenger(), G4HadronicEPTestMessenger::G4HadronicEPTestMessenger(), G4HadronicParametersMessenger::G4HadronicParametersMessenger(), G4INCLXXInterfaceMessenger::G4INCLXXInterfaceMessenger(), G4ModelCmdSetTimeSliceInterval< M >::G4ModelCmdSetTimeSliceInterval(), G4NeutronKillerMessenger::G4NeutronKillerMessenger(), G4RadioactivationMessenger::G4RadioactivationMessenger(), G4RadioactiveDecayMessenger::G4RadioactiveDecayMessenger(), G4SchedulerMessenger::G4SchedulerMessenger(), GFlashShowerModelMessenger::GFlashShowerModelMessenger(), PhysicsListMessenger::PhysicsListMessenger(), SetDefaultUnit(), and G4GenericMessenger::Command::SetUnit().

◆ SetWorkerThreadOnly()

void G4UIcommand::SetWorkerThreadOnly ( G4bool val = true )

inlineinherited

Definition at line 176 of file G4UIcommand.hh.

176{ workerThreadOnly=val; }

References G4UIcommand::workerThreadOnly.

Referenced by G4UIcommandTree::AddNewCommand(), and G4GenericMessenger::Command::SetWorkerThreadOnly().

◆ ToBeBroadcasted()

G4bool G4UIcommand::ToBeBroadcasted ( ) const

inlineinherited

Definition at line 173 of file G4UIcommand.hh.

173{ return toBeBroadcasted; }

References G4UIcommand::toBeBroadcasted.

Referenced by G4UIcommandTree::AddNewCommand(), and G4UImanager::ApplyCommand().

◆ ToBeFlushed()

G4bool G4UIcommand::ToBeFlushed ( ) const

inlineinherited

Definition at line 175 of file G4UIcommand.hh.

175{ return toBeFlushed; }

References G4UIcommand::toBeFlushed.

◆ TypeCheck()

G4int G4UIcommand::TypeCheck ( const char * t )

privateinherited

Definition at line 638 of file G4UIcommand.cc.

{
  G4String aNewValue;
  char type;
  std::istringstream is(t);
  for(unsigned i = 0; i < parameter.size(); ++i)
  {
    is >> aNewValue;
    type = toupper(parameter[i]->GetParameterType());
    switch(type)
    {
      case 'D':
        if(IsDouble(aNewValue) == 0)
        {
          G4cerr << aNewValue << ": double value expected." << G4endl;
          return 0;
        }
        break;
      case 'I':
        if(IsInt(aNewValue, 10) == 0)
        {
          G4cerr << aNewValue << ": integer expected." << G4endl;
          return 0;
        }
        break;
      case 'L':
        if(IsInt(aNewValue, 20) == 0)
        {
          G4cerr << aNewValue << ": long int expected." << G4endl;
          return 0;
        }
        break;
      case 'S':
        break;
      case 'B':
        G4StrUtil::to_upper(aNewValue);
        if(aNewValue == "Y" || aNewValue == "N" || aNewValue == "YES" ||
           aNewValue == "NO" || aNewValue == "1" || aNewValue == "0" ||
           aNewValue == "T" || aNewValue == "F" || aNewValue == "TRUE" ||
           aNewValue == "FALSE")
          return 1;
        else
          return 0;
        break;
      default:;
    }
  }
  return 1;
}

References G4cerr, G4endl, G4UIcommand::IsDouble(), G4UIcommand::IsInt(), G4UIcommand::parameter, and G4StrUtil::to_upper().

◆ UnaryExpression()

yystype G4UIcommand::UnaryExpression ( void )

privateinherited

Definition at line 1089 of file G4UIcommand.cc.

{
  yystype result;
  yystype p;
#ifdef DEBUG
  G4cerr << " UnaryExpression" << G4endl;
#endif
  switch(token)
  {
    case '-':
      token = Yylex();
      p     = UnaryExpression();
      if(p.type == CONSTINT)
      {
        result.I    = -p.I;
        result.type = CONSTINT;
      }
      if(p.type == CONSTLONG)
      {
        result.L    = -p.L;
        result.type = CONSTLONG;
      }
      if(p.type == CONSTDOUBLE)
      {
        result.D    = -p.D;
        result.type = CONSTDOUBLE;
      }
      break;
    case '+':
      token  = Yylex();
      result = UnaryExpression();
      break;
    case '!':
      token = Yylex();
      G4cerr << "Parameter range error: "
             << "operator '!' is not supported (sorry)." << G4endl;
      paramERR = 1;
      result   = UnaryExpression();
      break;
    default:
      result = PrimaryExpression();
  }
  return result;
}

References G4UItokenNum::CONSTDOUBLE, G4UItokenNum::CONSTINT, G4UItokenNum::CONSTLONG, G4UItokenNum::yystype::D, G4cerr, G4endl, G4UItokenNum::yystype::I, G4UItokenNum::yystype::L, G4UIcommand::paramERR, G4UIcommand::PrimaryExpression(), G4UIcommand::token, G4UItokenNum::yystype::type, G4UIcommand::UnaryExpression(), and G4UIcommand::Yylex().

Referenced by G4UIcommand::MultiplicativeExpression(), and G4UIcommand::UnaryExpression().

◆ UnitsList()

G4String G4UIcommand::UnitsList ( const char * unitCategory )

staticinherited

Definition at line 377 of file G4UIcommand.cc.

{
  G4String retStr;
  G4UnitsTable& UTbl = G4UnitDefinition::GetUnitsTable();
  std::size_t i;
  for(i = 0; i < UTbl.size(); ++i)
  {
    if(UTbl[i]->GetName() == unitCategory)
      break;
  }
  if(i == UTbl.size())
  {
    G4cerr << "Unit category <" << unitCategory << "> is not defined."
           << G4endl;
    return retStr;
  }
  G4UnitsContainer& UCnt = UTbl[i]->GetUnitsList();
  retStr                 = UCnt[0]->GetSymbol();
  G4int je               = UCnt.size();
  for(G4int j = 1; j < je; ++j)
  {
    retStr += " ";
    retStr += UCnt[j]->GetSymbol();
  }
  for(G4int k = 0; k < je; ++k)
  {
    retStr += " ";
    retStr += UCnt[k]->GetName();
  }
  return retStr;
}

References G4cerr, G4endl, and G4UnitDefinition::GetUnitsTable().

Referenced by G4MatScanMessenger::G4MatScanMessenger(), G4UserPhysicsListMessenger::G4UserPhysicsListMessenger(), G4UIparameter::SetDefaultUnit(), G4UIcmdWith3VectorAndUnit::SetUnitCategory(), and SetUnitCategory().

◆ ValueOf()

G4double G4UIcommand::ValueOf ( const char * unitName )

staticinherited

Definition at line 363 of file G4UIcommand.cc.

{
  G4double value = 0.;
  value = G4UnitDefinition::GetValueOf(unitName);
  return value;
}

References G4UnitDefinition::GetValueOf().

◆ Yylex()

tokenNum G4UIcommand::Yylex ( void )

privateinherited

Definition at line 1506 of file G4UIcommand.cc.

{                              // (returns EOF)
  G4int c;
  G4String buf;
 
  while((c = G4UIpGetc()) == ' ' || c == '\t' || c == '\n')
    ;
  if(c == EOF)
    return (tokenNum) EOF;  // KR488
  buf = "";
  if(isdigit(c) || c == '.')
  {  // I or D
    do
    {
      buf += (unsigned char)c;
      c = G4UIpGetc();
    } while(c == '.' || isdigit(c) || c == 'e' || c == 'E' || c == '+' ||
            c == '-');
    G4UIpUngetc(c);
    const char* t = buf;
    std::istringstream is(t);
    if(IsInt(buf.data(), 20))
    {
      is >> yylval.I;
      return CONSTINT;
    }
    else if(IsDouble(buf.data()))
    {
      is >> yylval.D;
      return CONSTDOUBLE;
    }
    else
    {
      G4cerr << buf << ": numeric format error." << G4endl;
    }
  }
  buf = "";
  if(isalpha(c) || c == '_')
  {  // IDENTIFIER
    do
    {
      buf += (unsigned char) c;
    } while((c = G4UIpGetc()) != EOF && (isalnum(c) || c == '_'));
    G4UIpUngetc(c);
    if(IsParameter(buf))
    {
      yylval.S = buf;
      return IDENTIFIER;
    }
    else
    {
      G4cerr << buf << " is not a parameter name." << G4endl;
      paramERR = 1;
    }
  }
  switch(c)
  {
    case '>':
      return (tokenNum) Follow('=', GE, GT);
    case '<':
      return (tokenNum) Follow('=', LE, LT);
    case '=':
      return (tokenNum) Follow('=', EQ, '=');
    case '!':
      return (tokenNum) Follow('=', NE, '!');
    case '|':
      return (tokenNum) Follow('|', LOGICALOR, '|');
    case '&':
      return (tokenNum) Follow('&', LOGICALAND, '&');
    default:
      return (tokenNum) c;
  }
}

References G4UItokenNum::CONSTDOUBLE, G4UItokenNum::CONSTINT, G4UItokenNum::yystype::D, EQ, G4UIcommand::Follow(), G4cerr, G4endl, G4UIcommand::G4UIpGetc(), G4UIcommand::G4UIpUngetc(), GE, GT, G4UItokenNum::yystype::I, G4UItokenNum::IDENTIFIER, G4UIcommand::IsDouble(), G4UIcommand::IsInt(), G4UIcommand::IsParameter(), LE, G4UItokenNum::LOGICALAND, G4UItokenNum::LOGICALOR, LT, NE, G4UIcommand::paramERR, G4UItokenNum::yystype::S, and G4UIcommand::yylval.

Referenced by G4UIcommand::EqualityExpression(), G4UIcommand::LogicalANDExpression(), G4UIcommand::LogicalORExpression(), G4UIcommand::PrimaryExpression(), G4UIcommand::RangeCheck(), G4UIcommand::RelationalExpression(), and G4UIcommand::UnaryExpression().

Field Documentation

◆ availabelStateList

std::vector<G4ApplicationState> G4UIcommand::availabelStateList

privateinherited

Definition at line 273 of file G4UIcommand.hh.

Referenced by G4UIcommand::AvailableForStates(), G4UIcommand::G4UIcommand(), G4UIcommand::GetStateList(), and G4UIcommand::IsAvailable().

◆ bp

G4int G4UIcommand::bp = 0

privateinherited

Definition at line 276 of file G4UIcommand.hh.

Referenced by G4UIcommand::G4UIpGetc(), G4UIcommand::G4UIpUngetc(), and G4UIcommand::RangeCheck().

◆ commandFailureCode

G4int G4UIcommand::commandFailureCode = 0

protectedinherited

Definition at line 223 of file G4UIcommand.hh.

Referenced by G4UIcommand::CommandFailed(), G4UIcommand::IfCommandFailed(), and G4UIcommand::ResetFailure().

◆ commandGuidance

std::vector<G4String> G4UIcommand::commandGuidance

privateinherited

Definition at line 272 of file G4UIcommand.hh.

Referenced by G4UIcommand::GetGuidanceEntries(), G4UIcommand::GetGuidanceLine(), G4UIcommand::GetTitle(), G4UIcommand::List(), and G4UIcommand::SetGuidance().

◆ commandName

G4String G4UIcommand::commandName

privateinherited

Definition at line 269 of file G4UIcommand.hh.

Referenced by G4UIcommand::Eval2(), G4UIcommand::G4UIcommandCommonConstructorCode(), and G4UIcommand::GetCommandName().

◆ commandPath

G4String G4UIcommand::commandPath

privateinherited

Definition at line 268 of file G4UIcommand.hh.

Referenced by G4UIcommand::G4UIcommandCommonConstructorCode(), G4UIcommand::GetCommandPath(), G4UIcommand::List(), G4UIcommand::operator!=(), G4UIcommand::operator==(), and G4UIcommand::SetCommandType().

◆ commandType

CommandType G4UIcommand::commandType = BaseClassCmd

privateinherited

Definition at line 266 of file G4UIcommand.hh.

Referenced by G4UIcommand::GetCommandType(), and G4UIcommand::SetCommandType().

◆ failureDescription

G4String G4UIcommand::failureDescription = ""

protectedinherited

Definition at line 224 of file G4UIcommand.hh.

Referenced by G4UIcommand::CommandFailed(), G4UIcommand::GetFailureDescription(), and G4UIcommand::ResetFailure().

◆ ifSort

G4bool G4UIcommand::ifSort = false

protectedinherited

Definition at line 226 of file G4UIcommand.hh.

Referenced by G4UIdirectory::IfSort(), G4UIcommand::SetDefaultSortFlag(), and G4UIdirectory::Sort().

◆ messenger

G4UImessenger* G4UIcommand::messenger = nullptr

privateinherited

Definition at line 267 of file G4UIcommand.hh.

Referenced by G4UIcommand::DoIt(), G4UIcommand::G4UIcommandCommonConstructorCode(), G4UIcommand::GetCurrentValue(), G4UIcommand::GetMessenger(), and G4UIcommand::SetCommandType().

◆ newVal

std::vector<yystype> G4UIcommand::newVal

privateinherited

Definition at line 279 of file G4UIcommand.hh.

Referenced by G4UIcommand::Eval2(), G4UIcommand::RangeCheck(), and G4UIcommand::SetParameter().

◆ paramERR

G4int G4UIcommand::paramERR = 0

privateinherited

Definition at line 280 of file G4UIcommand.hh.

Referenced by G4UIcommand::AdditiveExpression(), G4UIcommand::CompareDouble(), G4UIcommand::CompareInt(), G4UIcommand::CompareLong(), G4UIcommand::EqualityExpression(), G4UIcommand::Eval2(), G4UIcommand::G4UIpUngetc(), G4UIcommand::IndexOf(), G4UIcommand::LogicalANDExpression(), G4UIcommand::LogicalORExpression(), G4UIcommand::MultiplicativeExpression(), G4UIcommand::PrimaryExpression(), G4UIcommand::RangeCheck(), G4UIcommand::UnaryExpression(), and G4UIcommand::Yylex().

◆ parameter

std::vector<G4UIparameter*> G4UIcommand::parameter

privateinherited

Definition at line 271 of file G4UIcommand.hh.

Referenced by G4UIcommand::DoIt(), G4UIcommand::Eval2(), G4UIcommand::GetParameter(), G4UIcommand::GetParameterEntries(), G4UIcommand::IndexOf(), G4UIcommand::IsParameter(), G4UIcommand::List(), G4UIcommand::RangeCheck(), G4UIcommand::SetParameter(), G4UIcommand::TypeCheck(), and G4UIcommand::~G4UIcommand().

◆ rangeBuf

G4String G4UIcommand::rangeBuf

privateinherited

Definition at line 275 of file G4UIcommand.hh.

◆ rangeString

G4String G4UIcommand::rangeString

privateinherited

Definition at line 270 of file G4UIcommand.hh.

Referenced by G4UIcommand::CheckNewValue(), G4UIcommand::Eval2(), G4UIcommand::G4UIpGetc(), G4UIcommand::G4UIpUngetc(), G4UIcommand::GetRange(), G4UIcommand::List(), G4UIcommand::RangeCheck(), and G4UIcommand::SetRange().

◆ toBeBroadcasted

G4bool G4UIcommand::toBeBroadcasted = false

protectedinherited

Definition at line 219 of file G4UIcommand.hh.

Referenced by G4UIcommand::G4UIcommandCommonConstructorCode(), G4UIcommand::SetToBeBroadcasted(), and G4UIcommand::ToBeBroadcasted().

◆ toBeFlushed

G4bool G4UIcommand::toBeFlushed = false

protectedinherited

Definition at line 220 of file G4UIcommand.hh.

Referenced by G4UIcommand::SetToBeFlushed(), and G4UIcommand::ToBeFlushed().

◆ token

tokenNum G4UIcommand::token = G4UItokenNum::IDENTIFIER

privateinherited

Definition at line 277 of file G4UIcommand.hh.

Referenced by G4UIcommand::AdditiveExpression(), G4UIcommand::EqualityExpression(), G4UIcommand::LogicalANDExpression(), G4UIcommand::LogicalORExpression(), G4UIcommand::MultiplicativeExpression(), G4UIcommand::PrimaryExpression(), G4UIcommand::RangeCheck(), G4UIcommand::RelationalExpression(), and G4UIcommand::UnaryExpression().

◆ workerThreadOnly

G4bool G4UIcommand::workerThreadOnly = false

protectedinherited

Definition at line 221 of file G4UIcommand.hh.

Referenced by G4UIcommand::DoIt(), G4UIcommand::IsWorkerThreadOnly(), G4UIcommand::List(), and G4UIcommand::SetWorkerThreadOnly().

◆ yylval

yystype G4UIcommand::yylval

privateinherited

Definition at line 278 of file G4UIcommand.hh.

Referenced by G4UIcommand::PrimaryExpression(), and G4UIcommand::Yylex().

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

source/intercoms/include/G4UIcmdWithADoubleAndUnit.hh
source/intercoms/src/G4UIcmdWithADoubleAndUnit.cc

Public Types

Public Member Functions

Static Public Member Functions

Protected Types

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ tokenNum

◆ yystype

Member Enumeration Documentation

◆ CommandType

Constructor & Destructor Documentation

◆ G4UIcmdWithADoubleAndUnit()

Member Function Documentation

◆ AdditiveExpression()

◆ AvailableForStates() [1/5]

◆ AvailableForStates() [2/5]

◆ AvailableForStates() [3/5]

◆ AvailableForStates() [4/5]

◆ AvailableForStates() [5/5]

◆ Backslash()

◆ CategoryOf()

◆ CheckNewValue()

◆ CommandFailed() [1/2]

◆ CommandFailed() [2/2]

◆ CompareDouble()

◆ CompareInt()

◆ CompareLong()

◆ ConvertTo3Vector()

◆ ConvertToBool()

◆ ConvertToDimensioned3Vector()

◆ ConvertToDimensionedDouble()

◆ ConvertToDouble()

◆ ConvertToInt()

◆ ConvertToLongInt()

◆ ConvertToString() [1/7]

◆ ConvertToString() [2/7]

◆ ConvertToString() [3/7]

◆ ConvertToString() [4/7]

◆ ConvertToString() [5/7]

◆ ConvertToString() [6/7]

◆ ConvertToString() [7/7]

◆ ConvertToStringWithBestUnit()

◆ ConvertToStringWithDefaultUnit()

◆ DoIt()

◆ EqualityExpression()

◆ Eval2()

◆ ExpectExponent()

◆ Expression()

◆ Follow()

◆ G4UIcommandCommonConstructorCode()

◆ G4UIpGetc()

◆ G4UIpUngetc()

◆ GetCommandName()

◆ GetCommandPath()

◆ GetCommandType()

◆ GetCurrentValue()

◆ GetFailureDescription()

◆ GetGuidanceEntries()

◆ GetGuidanceLine()

◆ GetMessenger()

◆ GetNewDoubleRawValue()

◆ GetNewDoubleValue()

◆ GetNewUnitValue()

◆ GetParameter()

◆ GetParameterEntries()

◆ GetRange()

◆ GetStateList()

◆ GetTitle()

◆ IfCommandFailed()

◆ IndexOf()

◆ IsAvailable()

◆ IsDouble()

◆ IsInt()

◆ IsParameter()

◆ IsWorkerThreadOnly()

◆ List()