#include <G4VisCommandsSceneAdd.hh>

Inheritance diagram for G4VisCommandSceneAddVolume:

Public Member Functions
G4bool	CommandsShouldBeInMaster () const

	G4VisCommandSceneAddVolume ()

G4String	GetCurrentValue (G4UIcommand *command)

G4bool	operator!= (const G4UImessenger &messenger) const

G4bool	operator== (const G4UImessenger &messenger) const

void	SetNewValue (G4UIcommand *command, G4String newValue)

virtual	~G4VisCommandSceneAddVolume ()

Static Public Member Functions
static const G4Colour &	GetCurrentTextColour ()

static G4VisManager *	GetVisManager ()

static void	SetVisManager (G4VisManager *pVisManager)

Protected Member Functions
void	AddUIcommand (G4UIcommand *newCommand)

G4String	BtoS (G4bool b)

void	CheckSceneAndNotifyHandlers (G4Scene *=nullptr)

G4bool	CheckView ()

void	ConvertToColour (G4Colour &colour, const G4String &redOrString, G4double green, G4double blue, G4double opacity)

const G4String &	ConvertToColourGuidance ()

void	CopyCameraParameters (G4ViewParameters &target, const G4ViewParameters &from)

void	CopyGuidanceFrom (const G4UIcommand fromCmd, G4UIcommand toCmd, G4int startLine=0)

void	CopyMostViewParameters (G4ViewParameters &target, const G4ViewParameters &from)

void	CopyParametersFrom (const G4UIcommand fromCmd, G4UIcommand toCmd)

template<typename T >
T *	CreateCommand (const G4String &cname, const G4String &dsc)

void	CreateDirectory (const G4String &path, const G4String &dsc, G4bool commandsToBeBroadcasted=true)

G4String	CurrentSceneName ()

void	DrawExtent (const G4VisExtent &)

G4String	DtoS (G4double a)

void	G4VisCommandsSceneAddUnsuccessful (G4VisManager::Verbosity verbosity)

void	InterpolateToNewView (G4VViewer *currentViewer, const G4ViewParameters &oldVP, const G4ViewParameters &newVP, const G4int nInterpolationPoints=50, const G4int waitTimePerPointmilliseconds=20, const G4String exportString="")

void	InterpolateViews (G4VViewer *currentViewer, std::vector< G4ViewParameters > viewVector, const G4int nInterpolationPoints=50, const G4int waitTimePerPointmilliseconds=20, const G4String exportString="")

G4String	ItoS (G4int i)

G4bool	ProvideValueOfUnit (const G4String &where, const G4String &unit, const G4String &category, G4double &value)

void	RefreshIfRequired (G4VViewer *viewer)

void	SetViewParameters (G4VViewer *viewer, const G4ViewParameters &viewParams)

G4bool	StoB (G4String s)

G4double	StoD (G4String s)

G4int	StoI (G4String s)

G4long	StoL (G4String s)

Static Protected Member Functions
static G4bool	ConvertToDoublePair (const G4String &paramString, G4double &xval, G4double &yval)

static G4String	ConvertToString (G4double x, G4double y, const char *unitName)

Protected Attributes
G4UIdirectory *	baseDir = nullptr

G4String	baseDirName = ""

G4bool	commandsShouldBeInMaster = false

Static Protected Attributes
static G4int	fCurrentArrow3DLineSegmentsPerCircle = 6

static G4Colour	fCurrentColour = G4Colour::White()

static G4VisExtent	fCurrentExtentForField

static G4double	fCurrentLineWidth = 1.

static G4Colour	fCurrentTextColour = G4Colour::Blue()

static G4Text::Layout	fCurrentTextLayout = G4Text::left

static G4double	fCurrentTextSize = 12.

static G4PhysicalVolumeModel::TouchableProperties	fCurrentTouchableProperties

static std::vector< G4PhysicalVolumesSearchScene::Findings >	fCurrrentPVFindingsForField

static G4VisManager *	fpVisManager = nullptr

static G4bool	fThereWasAViewer = false

static G4ViewParameters	fVPExistingViewer

Private Member Functions
	G4VisCommandSceneAddVolume (const G4VisCommandSceneAddVolume &)

G4VisCommandSceneAddVolume &	operator= (const G4VisCommandSceneAddVolume &)

Private Attributes
G4UIcommand *	fpCommand

Detailed Description

Definition at line 479 of file G4VisCommandsSceneAdd.hh.

Constructor & Destructor Documentation

◆ G4VisCommandSceneAddVolume() [1/2]

G4VisCommandSceneAddVolume::G4VisCommandSceneAddVolume ( )

Definition at line 3033 of file G4VisCommandsSceneAdd.cc.

                                                        {
  G4bool omitable;
  fpCommand = new G4UIcommand ("/vis/scene/add/volume", this);
  fpCommand -> SetGuidance 
   ("Adds a physical volume to current scene, with optional clipping volume.");
  fpCommand -> SetGuidance 
    ("If physical-volume-name is \"world\" (the default), the top of the"
     "\nmain geometry tree (material world) is added. If \"worlds\", the"
     "\ntops of all worlds - material world and parallel worlds, if any - are"
     "\nadded. Otherwise a search of all worlds is made.");
  fpCommand -> SetGuidance
    ("In the last case the names of all volumes in all worlds are matched"
     "\nagainst physical-volume-name. If this is of the form \"/regexp/\","
     "\nwhere regexp is a regular expression (see C++ regex), the match uses"
     "\nthe usual rules of regular expression matching. Otherwise an exact"
     "\nmatch is required."
     "\nFor example, \"/Shap/\" adds \"Shape1\" and \"Shape2\".");
  fpCommand -> SetGuidance
    ("It may help to see a textual representation of the geometry hierarchy of"
     "\nthe worlds. Try \"/vis/drawTree [worlds]\" or one of the driver/browser"
     "\ncombinations that have the required functionality, e.g., HepRepFile.");
  fpCommand -> SetGuidance
    ("If clip-volume-type is specified, the subsequent parameters are used to"
     "\nto define a clipping volume. For example,"
     "\n\"/vis/scene/add/volume ! ! ! -box km 0 1 0 1 0 1\" will draw the world"
     "\nwith the positive octant cut away. (If the Boolean Processor issues"
     "\nwarnings try replacing 0 by 0.000000001 or something.)");
  fpCommand -> SetGuidance
    ("If clip-volume-type is prepended with '-', the clip-volume is subtracted"
     "\n(cutaway). (This is the default if there is no prepended character.)"
     "\nIf '*' is prepended, the intersection of the physical-volume and the"
     "\nclip-volume is made. (You can make a section through the detector with"
     "\na thin box, for example).");
  fpCommand -> SetGuidance
    ("For \"box\", the parameters are xmin,xmax,ymin,ymax,zmin,zmax."
     "\nOnly \"box\" is programmed at present.");
  G4UIparameter* parameter;
  parameter = new G4UIparameter ("physical-volume-name", 's', omitable = true);
  parameter -> SetDefaultValue ("world");
  fpCommand -> SetParameter (parameter);
  parameter = new G4UIparameter ("copy-no", 'i', omitable = true);
  parameter -> SetGuidance ("If negative, matches any copy no.");
  parameter -> SetDefaultValue (-1);
  fpCommand -> SetParameter (parameter);
  parameter = new G4UIparameter ("depth-of-descent", 'i', omitable = true);
  parameter -> SetGuidance
    ("Depth of descent of geometry hierarchy. Default = unlimited depth.");
  parameter -> SetDefaultValue (G4Scene::UNLIMITED);
  fpCommand -> SetParameter (parameter);
  parameter = new G4UIparameter ("clip-volume-type", 's', omitable = true);
  parameter -> SetParameterCandidates("none box -box *box");
  parameter -> SetDefaultValue ("none");
  parameter -> SetGuidance("[-|*]type.  See general guidance.");
  fpCommand -> SetParameter (parameter);
  parameter = new G4UIparameter ("parameter-unit", 's', omitable = true);
  parameter -> SetDefaultValue ("m");
  fpCommand -> SetParameter (parameter);
  parameter = new G4UIparameter ("parameter-1", 'd', omitable = true);
  parameter -> SetDefaultValue (0.);
  fpCommand -> SetParameter (parameter);
  parameter = new G4UIparameter ("parameter-2", 'd', omitable = true);
  parameter -> SetDefaultValue (0.);
  fpCommand -> SetParameter (parameter);
  parameter = new G4UIparameter ("parameter-3", 'd', omitable = true);
  parameter -> SetDefaultValue (0.);
  fpCommand -> SetParameter (parameter);
  parameter = new G4UIparameter ("parameter-4", 'd', omitable = true);
  parameter -> SetDefaultValue (0.);
  fpCommand -> SetParameter (parameter);
  parameter = new G4UIparameter ("parameter-5", 'd', omitable = true);
  parameter -> SetDefaultValue (0.);
  fpCommand -> SetParameter (parameter);
  parameter = new G4UIparameter ("parameter-6", 'd', omitable = true);
  parameter -> SetDefaultValue (0.);
  fpCommand -> SetParameter (parameter);
}

References G4VisCommandSceneAddText2D::fpCommand, and G4Scene::UNLIMITED.

◆ ~G4VisCommandSceneAddVolume()

G4VisCommandSceneAddVolume::~G4VisCommandSceneAddVolume ( )

virtual

Definition at line 3110 of file G4VisCommandsSceneAdd.cc.

                                                         {
  delete fpCommand;
}

References G4VisCommandSceneAddText2D::fpCommand.

◆ G4VisCommandSceneAddVolume() [2/2]

G4VisCommandSceneAddVolume::G4VisCommandSceneAddVolume ( const G4VisCommandSceneAddVolume & )

private

Member Function Documentation

◆ AddUIcommand()

void G4UImessenger::AddUIcommand ( G4UIcommand * newCommand )

protectedinherited

Definition at line 149 of file G4UImessenger.cc.

{
  G4cerr << "Warning : Old style definition of G4UIcommand <"
         << newCommand->GetCommandPath() << ">." << G4endl;
}

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

◆ BtoS()

G4String G4UImessenger::BtoS ( G4bool b )

protectedinherited

Definition at line 98 of file G4UImessenger.cc.

{
  G4String vl = "0";
  if(b)
    vl = "true";
  return vl;
}

◆ CheckSceneAndNotifyHandlers()

void G4VVisCommand::CheckSceneAndNotifyHandlers ( G4Scene * pScene = nullptr )

protectedinherited

Definition at line 207 of file G4VVisCommand.cc.

{
  G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
 
  if (!pScene) {
    if (verbosity >= G4VisManager::warnings) {
      G4cout << "WARNING: Scene pointer is null."
      << G4endl;
    }
    return;
  }
 
  G4VSceneHandler* pSceneHandler = fpVisManager -> GetCurrentSceneHandler();
  if (!pSceneHandler) {
    if (verbosity >= G4VisManager::warnings) {
      G4cout << "WARNING: Scene handler not found." << G4endl;
    }
    return;
  }
 
  // Scene has changed.  If it is the scene of the currrent scene handler
  // refresh viewers of all scene handlers using this scene. If not, it may be
  // a scene that the user is building up before attaching to a scene handler,
  // so do nothing.
  if (pScene == pSceneHandler->GetScene()) {
    G4UImanager::GetUIpointer () -> ApplyCommand ("/vis/scene/notifyHandlers");
  }
 
}

References G4VVisCommand::fpVisManager, G4cout, G4endl, G4VSceneHandler::GetScene(), G4UImanager::GetUIpointer(), G4VisManager::GetVerbosity(), and G4VisManager::warnings.

◆ CheckView()

G4bool G4VVisCommand::CheckView ( )

protectedinherited

Definition at line 237 of file G4VVisCommand.cc.

{
  G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
  G4VViewer* viewer = fpVisManager -> GetCurrentViewer ();
 
  if (!viewer) {
    if (verbosity >= G4VisManager::errors) {
      G4cerr <<
  "ERROR: No current viewer - \"/vis/viewer/list\" to see possibilities."
       << G4endl;
    }
    return false;
  }
  
  return true;
}

References G4VisManager::errors, G4VVisCommand::fpVisManager, G4cerr, G4endl, and G4VisManager::GetVerbosity().

◆ CommandsShouldBeInMaster()

G4bool G4UImessenger::CommandsShouldBeInMaster ( ) const

inlineinherited

Definition at line 77 of file G4UImessenger.hh.

    {
      return commandsShouldBeInMaster;
    }

References G4UImessenger::commandsShouldBeInMaster.

Referenced by G4UIcommand::G4UIcommandCommonConstructorCode().

◆ ConvertToColour()

void G4VVisCommand::ConvertToColour	(	G4Colour &	colour,
		const G4String &	redOrString,
		G4double	green,
		G4double	blue,
		G4double	opacity
	)

protectedinherited

Definition at line 119 of file G4VVisCommand.cc.

{
  // Note: colour is supplied by the caller and some or all of its components
  // may act as default.
  //
  // Note: redOrString is either a number or string.  If a string it must be
  // one of the recognised colours.
  //
  // Thus the arguments can be, for example:
  // (colour,"red",...,...,0.5): will give the colour red with opacity 0.5 (the
  // third and fourth arguments are ignored), or
  // (1.,0.,0.,0.5): this also will be red with opacity 0.5.
 
  G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
 
  const size_t iPos0 = 0;
  if (std::isalpha(redOrString[iPos0])) {
 
    // redOrString is probably alphabetic characters defining the colour
    if (!G4Colour::GetColour(redOrString, colour)) {
      // Not a recognised string
      if (verbosity >= G4VisManager::warnings) {
        G4cout << "WARNING: Colour \"" << redOrString
        << "\" not found.  Defaulting to " << colour
        << G4endl;
      }
      return;
    } else {
      // It was a recognised string.  Now add opacity.
      colour.SetAlpha(opacity);
      return;
    }
 
  } else {
 
    // redOrString is probably numeric defining the red component
    std::istringstream iss(redOrString);
    G4double red;
    iss >> red;
    if (iss.fail()) {
      if (verbosity >= G4VisManager::warnings) {
        G4cout << "WARNING: String \"" << redOrString
        << "\" cannot be parsed.  Defaulting to " << colour
        << G4endl;
      }
      return;
    } else {
      colour = G4Colour(red,green,blue,opacity);
      return;
    }
    
  }
}

References G4VVisCommand::fpVisManager, G4cout, G4endl, G4Colour::GetColour(), G4VisManager::GetVerbosity(), G4Colour::SetAlpha(), and G4VisManager::warnings.

Referenced by G4VisCommandGeometrySetColour::SetNewValue(), G4VisCommandSceneAddGPS::SetNewValue(), G4VisCommandSetColour::SetNewValue(), G4VisCommandSetTextColour::SetNewValue(), G4VisCommandsTouchableSet::SetNewValue(), and G4VisCommandsViewerSet::SetNewValue().

◆ ConvertToColourGuidance()

const G4String & G4VVisCommand::ConvertToColourGuidance ( )

protectedinherited

Definition at line 109 of file G4VVisCommand.cc.

{
  static G4String guidance
  ("Accepts (a) RGB triplet. e.g., \".3 .4 .5\", or"
   "\n (b) string such as \"white\", \"black\", \"grey\", \"red\"...or"
   "\n (c) an additional number for opacity, e.g., \".3 .4 .5 .6\""
   "\n     or \"grey ! ! .6\" (note \"!\"'s for unused parameters).");
  return guidance;
}

Referenced by G4VisCommandSceneAddGPS::G4VisCommandSceneAddGPS(), G4VisCommandSetColour::G4VisCommandSetColour(), G4VisCommandSetTextColour::G4VisCommandSetTextColour(), G4VisCommandsTouchableSet::G4VisCommandsTouchableSet(), and G4VisCommandsViewerSet::G4VisCommandsViewerSet().

◆ ConvertToDoublePair()

G4bool G4VVisCommand::ConvertToDoublePair	(	const G4String &	paramString,
		G4double &	xval,
		G4double &	yval
	)

staticprotectedinherited

Definition at line 85 of file G4VVisCommand.cc.

{
  G4double x, y;
  G4String unit;
  
  std::istringstream is(paramString);
  is >> x >> y >> unit;
 
  if (G4UnitDefinition::IsUnitDefined(unit)) {
    xval = x*G4UIcommand::ValueOf(unit);
    yval = y*G4UIcommand::ValueOf(unit);
  } else {
    G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
    if (verbosity >= G4VisManager::errors) {
      G4cout << "ERROR: Unrecognised unit" << G4endl;
    }
    return false;
  }
 
  return true;
}

References G4VisManager::errors, G4VVisCommand::fpVisManager, G4cout, G4endl, G4VisManager::GetVerbosity(), G4UnitDefinition::IsUnitDefined(), and G4UIcommand::ValueOf().

Referenced by G4VisCommandViewerPan::SetNewValue(), and G4VisCommandsViewerSet::SetNewValue().

◆ ConvertToString()

G4String G4VVisCommand::ConvertToString	(	G4double	x,
		G4double	y,
		const char *	unitName
	)

staticprotectedinherited

Definition at line 75 of file G4VVisCommand.cc.

{
  G4double uv = G4UIcommand::ValueOf(unitName);
  
  std::ostringstream oss;
  oss << x/uv << " " << y/uv << " " << unitName;
  return oss.str();
}

References G4UIcommand::ValueOf().

Referenced by G4VisCommandViewerPan::GetCurrentValue().

◆ CopyCameraParameters()

void G4VVisCommand::CopyCameraParameters	(	G4ViewParameters &	target,
		const G4ViewParameters &	from
	)

protectedinherited

Definition at line 385 of file G4VVisCommand.cc.

{
  // Copy view parameters pertaining only to camera
  target.SetViewpointDirection  (from.GetViewpointDirection());
  target.SetLightpointDirection (from.GetLightpointDirection());
  target.SetLightsMoveWithCamera(from.GetLightsMoveWithCamera());
  target.SetUpVector            (from.GetUpVector());
  target.SetFieldHalfAngle      (from.GetFieldHalfAngle());
  target.SetZoomFactor          (from.GetZoomFactor());
  target.SetScaleFactor         (from.GetScaleFactor());
  target.SetCurrentTargetPoint  (from.GetCurrentTargetPoint());
  target.SetDolly               (from.GetDolly());
}

Referenced by G4VisCommandViewerCopyViewFrom::SetNewValue().

◆ CopyGuidanceFrom()

void G4VVisCommand::CopyGuidanceFrom	(	const G4UIcommand *	fromCmd,
		G4UIcommand *	toCmd,
		G4int	startLine = `0`
	)

protectedinherited

Definition at line 335 of file G4VVisCommand.cc.

{
  if (fromCmd && toCmd) {
    const G4int nGuideEntries = fromCmd->GetGuidanceEntries();
    for (G4int i = startLine; i < nGuideEntries; ++i) {
      const G4String& guidance = fromCmd->GetGuidanceLine(i);
      toCmd->SetGuidance(guidance);
    }
  }
}

References G4UIcommand::GetGuidanceEntries(), G4UIcommand::GetGuidanceLine(), and G4UIcommand::SetGuidance().

Referenced by G4VisCommandDrawLogicalVolume::G4VisCommandDrawLogicalVolume(), G4VisCommandDrawVolume::G4VisCommandDrawVolume(), G4VisCommandSceneAddMagneticField::G4VisCommandSceneAddMagneticField(), G4VisCommandsTouchable::G4VisCommandsTouchable(), and G4VisCommandViewerCentreOn::G4VisCommandViewerCentreOn().

◆ CopyMostViewParameters()

void G4VVisCommand::CopyMostViewParameters	(	G4ViewParameters &	target,
		const G4ViewParameters &	from
	)

protectedinherited

Definition at line 374 of file G4VVisCommand.cc.

{
  // Copy view parameters except for autoRefresh and background...
  auto targetAutoRefresh = target.IsAutoRefresh();
  auto targetBackground  = target.GetBackgroundColour();
  target = from;
  target.SetAutoRefresh(targetAutoRefresh);
  target.SetBackgroundColour(targetBackground);
}

References G4ViewParameters::GetBackgroundColour(), G4ViewParameters::IsAutoRefresh(), G4ViewParameters::SetAutoRefresh(), and G4ViewParameters::SetBackgroundColour().

Referenced by G4VisCommandViewerCreate::SetNewValue(), and G4VisCommandsViewerSet::SetNewValue().

◆ CopyParametersFrom()

void G4VVisCommand::CopyParametersFrom	(	const G4UIcommand *	fromCmd,
		G4UIcommand *	toCmd
	)

protectedinherited

Definition at line 347 of file G4VVisCommand.cc.

{
  if (fromCmd && toCmd) {
    const G4int nParEntries = fromCmd->GetParameterEntries();
    for (G4int i = 0; i < nParEntries; ++i) {
      G4UIparameter* parameter = new G4UIparameter(*(fromCmd->GetParameter(i)));
      toCmd->SetParameter(parameter);
    }
  }
}

References G4UIcommand::GetParameter(), G4UIcommand::GetParameterEntries(), and G4UIcommand::SetParameter().

Referenced by G4VisCommandDrawLogicalVolume::G4VisCommandDrawLogicalVolume(), G4VisCommandDrawVolume::G4VisCommandDrawVolume(), G4VisCommandSceneAddMagneticField::G4VisCommandSceneAddMagneticField(), and G4VisCommandViewerCentreOn::G4VisCommandViewerCentreOn().

◆ CreateCommand()

template<typename T >

T * G4UImessenger::CreateCommand	(	const G4String &	cname,
		const G4String &	dsc
	)

protectedinherited

Definition at line 110 of file G4UImessenger.hh.

{
  G4String path;
  if(cname[0] != '/')
  {
    path = baseDirName + cname;
    if(path[0] != '/')
      path = "/" + path;
  }
 
  T* command = new T(path.c_str(), this);
  command->SetGuidance(dsc.c_str());
 
  return command;
}

References G4UImessenger::baseDirName.

◆ CreateDirectory()

void G4UImessenger::CreateDirectory	(	const G4String &	path,
		const G4String &	dsc,
		G4bool	commandsToBeBroadcasted = `true`
	)

protectedinherited

Definition at line 156 of file G4UImessenger.cc.

{
  G4UImanager* ui = G4UImanager::GetUIpointer();
 
  G4String fullpath = path;
  if(fullpath.back() != '/')
    fullpath.append("/");
 
  G4UIcommandTree* tree = ui->GetTree()->FindCommandTree(fullpath.c_str());
  if(tree != nullptr)
  {
    baseDirName = tree->GetPathName();
  }
  else
  {
    baseDir     = new G4UIdirectory(fullpath.c_str(), commandsToBeBroadcasted);
    baseDirName = fullpath;
    baseDir->SetGuidance(dsc.c_str());
  }
}

References G4UImessenger::baseDir, G4UImessenger::baseDirName, G4UIcommandTree::FindCommandTree(), G4UIcommandTree::GetPathName(), G4UImanager::GetTree(), G4UImanager::GetUIpointer(), and G4UIcommand::SetGuidance().

Referenced by G4MoleculeShootMessenger::G4MoleculeShootMessenger(), and G4UImessenger::G4UImessenger().

◆ CurrentSceneName()

G4String G4VVisCommandScene::CurrentSceneName ( )

protectedinherited

Definition at line 50 of file G4VisCommandsScene.cc.

                                               {
  const G4Scene* pScene = fpVisManager -> GetCurrentScene ();
  G4String currentSceneName = "none";
  if (pScene) currentSceneName = pScene -> GetName ();
  return currentSceneName;
}

References G4VVisCommand::fpVisManager.

Referenced by G4VisCommandSceneNotifyHandlers::GetCurrentValue().

◆ DrawExtent()

void G4VVisCommand::DrawExtent ( const G4VisExtent & extent )

protectedinherited

Definition at line 359 of file G4VVisCommand.cc.

{
  if (fpVisManager) {
    const G4double halfX = (extent.GetXmax() - extent.GetXmin()) / 2.;
    const G4double halfY = (extent.GetYmax() - extent.GetYmin()) / 2.;
    const G4double halfZ = (extent.GetZmax() - extent.GetZmin()) / 2.;
    if (halfX > 0. && halfY > 0. && halfZ > 0.) {
      const G4Box box("vis_extent",halfX,halfY,halfZ);
      const G4VisAttributes visAtts(G4Color::Red());
      const G4Point3D& centre = extent.GetExtentCenter();
      fpVisManager->Draw(box,visAtts,G4Translate3D(centre));
    }
  }
}

References G4VisManager::Draw(), G4VVisCommand::fpVisManager, G4VisExtent::GetExtentCenter(), G4VisExtent::GetXmax(), G4VisExtent::GetXmin(), G4VisExtent::GetYmax(), G4VisExtent::GetYmin(), G4VisExtent::GetZmax(), G4VisExtent::GetZmin(), and G4Colour::Red().

Referenced by G4VisCommandSceneShowExtents::SetNewValue(), G4VisCommandSetVolumeForField::SetNewValue(), and G4VisCommandsTouchable::SetNewValue().

◆ DtoS()

G4String G4UImessenger::DtoS ( G4double a )

protectedinherited

Definition at line 90 of file G4UImessenger.cc.

{
  std::ostringstream os;
  os << a;
  return G4String(os.str());
}

Referenced by G4ScoreQuantityMessenger::FilterCommands(), and G4UIcontrolMessenger::SetNewValue().

◆ G4VisCommandsSceneAddUnsuccessful()

void G4VVisCommand::G4VisCommandsSceneAddUnsuccessful ( G4VisManager::Verbosity verbosity )

protectedinherited

Definition at line 254 of file G4VVisCommand.cc.

                                  {
  // Some frequently used error printing...
  if (verbosity >= G4VisManager::warnings) {
    G4cout <<
    "WARNING: For some reason, possibly mentioned above, it has not been"
    "\n  possible to add to the scene."
    << G4endl;
  }
}

References G4cout, G4endl, and G4VisManager::warnings.

◆ GetCurrentTextColour()

const G4Colour & G4VVisCommand::GetCurrentTextColour ( )

staticinherited

Definition at line 70 of file G4VVisCommand.cc.

{
  return fCurrentTextColour;
}

References G4VVisCommand::fCurrentTextColour.

◆ GetCurrentValue()

G4String G4VisCommandSceneAddVolume::GetCurrentValue ( G4UIcommand * command )

virtual

Reimplemented from G4UImessenger.

Definition at line 3114 of file G4VisCommandsSceneAdd.cc.

                                                                  {
  return "world 0 -1";
}

◆ GetVisManager()

G4VisManager * G4VVisCommand::GetVisManager ( )

staticinherited

Definition at line 60 of file G4VVisCommand.cc.

{
  return fpVisManager;
}

References G4VVisCommand::fpVisManager.

◆ InterpolateToNewView()

void G4VVisCommand::InterpolateToNewView	(	G4VViewer *	currentViewer,
		const G4ViewParameters &	oldVP,
		const G4ViewParameters &	newVP,
		const G4int	nInterpolationPoints = `50`,
		const G4int	waitTimePerPointmilliseconds = `20`,
		const G4String	exportString = `""`
	)

protectedinherited

Definition at line 313 of file G4VVisCommand.cc.

{
  std::vector<G4ViewParameters> viewVector;
  viewVector.push_back(oldVP);
  viewVector.push_back(oldVP);
  viewVector.push_back(newVP);
  viewVector.push_back(newVP);
  
  InterpolateViews
  (currentViewer,
   viewVector,
   nInterpolationPoints,
   waitTimePerPointmilliseconds,
   exportString);
}

References G4VVisCommand::InterpolateViews().

Referenced by G4VisCommandsTouchable::SetNewValue(), and G4VisCommandViewerCentreOn::SetNewValue().

◆ InterpolateViews()

void G4VVisCommand::InterpolateViews	(	G4VViewer *	currentViewer,
		std::vector< G4ViewParameters >	viewVector,
		const G4int	nInterpolationPoints = `50`,
		const G4int	waitTimePerPointmilliseconds = `20`,
		const G4String	exportString = `""`
	)

protectedinherited

Definition at line 288 of file G4VVisCommand.cc.

{
  const G4int safety = viewVector.size()*nInterpolationPoints;
  G4int safetyCount = 0;
  do {
    G4ViewParameters* vp =
    G4ViewParameters::CatmullRomCubicSplineInterpolation(viewVector,nInterpolationPoints);
    if (!vp) break;  // Finished.
    currentViewer->SetViewParameters(*vp);
    currentViewer->RefreshView();
    if (exportString == "export" &&
        G4StrUtil::contains(currentViewer->GetName(), "OpenGL")) {
      G4UImanager::GetUIpointer()->ApplyCommand("/vis/ogl/export");
    }
    currentViewer->ShowView();
    if (waitTimePerPointmilliseconds > 0)
      std::this_thread::sleep_for(std::chrono::milliseconds(waitTimePerPointmilliseconds));
  } while (safetyCount++ < safety);  // Loop checking, 16.02.2016, J.Allison
}

References G4UImanager::ApplyCommand(), G4ViewParameters::CatmullRomCubicSplineInterpolation(), G4StrUtil::contains(), G4VViewer::GetName(), G4UImanager::GetUIpointer(), G4VViewer::RefreshView(), G4VViewer::SetViewParameters(), and G4VViewer::ShowView().

Referenced by G4VVisCommand::InterpolateToNewView(), and G4VisCommandViewerInterpolate::SetNewValue().

◆ ItoS()

G4String G4UImessenger::ItoS ( G4int i )

protectedinherited

Definition at line 82 of file G4UImessenger.cc.

{
  std::ostringstream os;
  os << i;
  return G4String(os.str());
}

Referenced by G4GenericMessenger::DeclareMethod(), and G4ParticleGunMessenger::GetCurrentValue().

◆ operator!=()

G4bool G4UImessenger::operator!= ( const G4UImessenger & messenger ) const

inherited

Definition at line 76 of file G4UImessenger.cc.

{
  return this != &messenger;
}

◆ operator=()

G4VisCommandSceneAddVolume & G4VisCommandSceneAddVolume::operator= ( const G4VisCommandSceneAddVolume & )

private

◆ operator==()

G4bool G4UImessenger::operator== ( const G4UImessenger & messenger ) const

inherited

Definition at line 70 of file G4UImessenger.cc.

{
  return this == &messenger;
}

◆ ProvideValueOfUnit()

G4bool G4VVisCommand::ProvideValueOfUnit	(	const G4String &	where,
		const G4String &	unit,
		const G4String &	category,
		G4double &	value
	)

protectedinherited

Definition at line 175 of file G4VVisCommand.cc.

{
  // Return false if there's a problem
 
  G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
 
  G4bool success = true;
  if (!G4UnitDefinition::IsUnitDefined(unit)) {
    if (verbosity >= G4VisManager::warnings) {
      G4cerr << where
      << "\n  Unit \"" << unit << "\" not defined"
      << G4endl;
    }
    success = false;
  } else if (G4UnitDefinition::GetCategory(unit) != category) {
    if (verbosity >= G4VisManager::warnings) {
      G4cerr << where
      << "\n  Unit \"" << unit << "\" not a unit of " << category;
      if (category == "Volumic Mass") G4cerr << " (density)";
      G4cerr << G4endl;
    }
    success = false;
  } else {
    value = G4UnitDefinition::GetValueOf(unit);
  }
  return success;
}

References G4VVisCommand::fpVisManager, G4cerr, G4endl, G4UnitDefinition::GetCategory(), G4UnitDefinition::GetValueOf(), G4VisManager::GetVerbosity(), G4UnitDefinition::IsUnitDefined(), and G4VisManager::warnings.

Referenced by G4VisCommandViewerColourByDensity::SetNewValue(), and G4VisCommandsViewerSet::SetNewValue().

◆ RefreshIfRequired()

void G4VVisCommand::RefreshIfRequired ( G4VViewer * viewer )

protectedinherited

Definition at line 271 of file G4VVisCommand.cc.

                                                       {
  G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
  G4VSceneHandler* sceneHandler = viewer->GetSceneHandler();
  const G4ViewParameters& viewParams = viewer->GetViewParameters();
  if (sceneHandler && sceneHandler->GetScene()) {
    if (viewParams.IsAutoRefresh()) {
      G4UImanager::GetUIpointer()->ApplyCommand("/vis/viewer/refresh");
    }
    else {
      if (verbosity >= G4VisManager::warnings) {
        G4cout << "Issue /vis/viewer/refresh or flush to see effect."
        << G4endl;
      }
    }
  }
}

References G4UImanager::ApplyCommand(), G4VVisCommand::fpVisManager, G4cout, G4endl, G4VSceneHandler::GetScene(), G4VViewer::GetSceneHandler(), G4UImanager::GetUIpointer(), G4VisManager::GetVerbosity(), G4VViewer::GetViewParameters(), G4ViewParameters::IsAutoRefresh(), and G4VisManager::warnings.

Referenced by G4VisCommandViewerReset::SetNewValue(), G4VisCommandViewerRebuild::SetNewValue(), G4VisCommandViewerSelect::SetNewValue(), and G4VVisCommand::SetViewParameters().

◆ SetNewValue()

void G4VisCommandSceneAddVolume::SetNewValue	(	G4UIcommand *	command,
		G4String	newValue
	)

virtual

Reimplemented from G4UImessenger.

Definition at line 3118 of file G4VisCommandsSceneAdd.cc.

                                             {
 
  G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
  G4bool warn = verbosity >= G4VisManager::warnings;
 
  G4Scene* pScene = fpVisManager->GetCurrentScene();
  if (!pScene) {
    if (verbosity >= G4VisManager::errors) {
      G4cerr << "ERROR: No current scene.  Please create one." << G4endl;
    }
    return;
  }
 
  G4String name, clipVolumeType, parameterUnit;
  G4int copyNo, requestedDepthOfDescent;
  G4double param1, param2, param3, param4, param5, param6;
  std::istringstream is (newValue);
  is >> name >> copyNo >> requestedDepthOfDescent
     >> clipVolumeType >> parameterUnit
     >> param1 >> param2 >> param3 >> param4 >> param5 >> param6;
  G4PhysicalVolumeModel::ClippingMode clippingMode =
    G4PhysicalVolumeModel::subtraction;  // Default subtraction mode.
  if (clipVolumeType[size_t(0)] == '-') {
    clipVolumeType = clipVolumeType.substr(1);  // Remove first character.
  } else if (clipVolumeType[size_t(0)] == '*') {
    clippingMode = G4PhysicalVolumeModel::intersection;
    clipVolumeType = clipVolumeType.substr(1);
  }
  G4double unit = G4UIcommand::ValueOf(parameterUnit);
  param1 *= unit; param2 *= unit; param3 *= unit;
  param4 *= unit; param5 *= unit; param6 *= unit;
 
  G4VSolid* clippingSolid = nullptr;
  if (clipVolumeType == "box") {
    const G4double dX = (param2 - param1) / 2.;
    const G4double dY = (param4 - param3) / 2.;
    const G4double dZ = (param6 - param5) / 2.;
    const G4double x0 = (param2 + param1) / 2.;
    const G4double y0 = (param4 + param3) / 2.;
    const G4double z0 = (param6 + param5) / 2.;
    clippingSolid = new G4DisplacedSolid
    ("_displaced_clipping_box",
     new G4Box("_clipping_box",dX,dY,dZ),
     G4Translate3D(x0,y0,z0));
  }
 
  G4TransportationManager* transportationManager =
    G4TransportationManager::GetTransportationManager ();
 
  size_t nWorlds = transportationManager->GetNoWorlds();
  if (nWorlds > 1) {  // Parallel worlds in operation...
    if (verbosity >= G4VisManager::warnings) {
      static G4bool warned = false;
      if (!warned && name != "worlds") {
    G4cout <<
      "WARNING: Parallel worlds in operation.  To visualise, specify"
      "\n  \"worlds\" or the parallel world volume or sub-volume name"
      "\n   and control visibility with /vis/geometry."
           << G4endl;
    std::vector<G4VPhysicalVolume*>::iterator iterWorld =
      transportationManager->GetWorldsIterator();
    for (size_t i = 0; i < nWorlds; ++i, ++iterWorld) {
      G4cout << "  World " << i << ": " << (*iterWorld)->GetName()
         << G4endl;
      warned = true;
    }
      }
    }
  }
 
  // Get the world (the initial value of the iterator points to the mass world).
  G4VPhysicalVolume* world = *(transportationManager->GetWorldsIterator());
 
  if (!world) {
    if (verbosity >= G4VisManager::errors) {
      G4cerr <<
    "ERROR: G4VisCommandSceneAddVolume::SetNewValue:"
    "\n  No world.  Maybe the geometry has not yet been defined."
    "\n  Try \"/run/initialize\""
         << G4endl;
    }
    return;
  }
 
  std::vector<G4PhysicalVolumesSearchScene::Findings> findingsVector;
 
  // When it comes to determining the extent of a physical volume we normally
  // assume the user wishes to ignore "invisible" volumes. For example, most
  // users make the world volume invisible. So we ask the physical volume
  // model to traverse the geometry hierarchy, starting at the named physical
  // volume, until it finds non-invisible ones, whose extents are accumulated
  // to determine the overall extent. (Once a non-invisible volume is found,
  // the search is curtailed - daughters are always contained within the mother
  // so they have no subsequent influence on the extent of the mother - but the
  // search continues at the same level until all highest level non-invisible
  // volumes are found an their extents accumulated.) So the default is
  G4bool useFullExtent = false;
  // However, the above procedure can be time consuming in some situations, such
  // as a nested parameterisation whose ultimate volumes are the first non-
  // visible ones, which are typical of a medical "phantom". So we assume here
  // below that if a user specifies a name other than "world" or "worlds" he/she
  // wished the extent to be determined by the volume, whether it is visible
  // or not. So we set useFullExtent true at that point below.
 
  if (name == "world") {
 
    findingsVector.push_back
    (G4PhysicalVolumesSearchScene::Findings(world,world));
 
  } else if (name == "worlds") {
 
    if (nWorlds <= 1) {
      if (verbosity >= G4VisManager::warnings) {
    G4cout <<
      "WARNING: G4VisCommandSceneAddVolume::SetNewValue:"
      "\n  Parallel worlds requested but none exist."
      "\n  Just adding material world."
           << G4endl;
      }
    }
    std::vector<G4VPhysicalVolume*>::iterator iterWorld =
      transportationManager->GetWorldsIterator();
    for (size_t i = 0; i < nWorlds; ++i, ++iterWorld) {
      findingsVector.push_back
      (G4PhysicalVolumesSearchScene::Findings
       (*iterWorld,*iterWorld));
    }
 
  } else {  // Search all worlds...
 
    // Use the model's full extent. This assumes the user wants these
    // volumes in the findings vector (there could be more than one) to
    // determine the scene's extent. Otherwise G4PhysicalVolumeModel would
    // re-calculate each volume's extent based on visibility, etc., which
    // could be time consuming.
    useFullExtent = true;
 
    std::vector<G4VPhysicalVolume*>::iterator iterWorld =
      transportationManager->GetWorldsIterator();
    for (size_t i = 0; i < nWorlds; ++i, ++iterWorld) {
      G4ModelingParameters mp;  // Default - no culling.
      G4PhysicalVolumeModel searchModel
      (*iterWorld,
       G4PhysicalVolumeModel::UNLIMITED,
       G4Transform3D(),
       &mp,
       useFullExtent);
      G4PhysicalVolumesSearchScene searchScene
      (&searchModel, name, copyNo, requestedDepthOfDescent);
      searchModel.DescribeYourselfTo (searchScene);  // Initiate search.
      for (const auto& findings: searchScene.GetFindings()) {
        findingsVector.push_back(findings);
      }
    }
  }
 
  for (const auto& findings: findingsVector) {
    // Set copy number from search findings for replicas and parameterisations.
    findings.fpFoundPV->SetCopyNo(findings.fFoundPVCopyNo);
    G4PhysicalVolumeModel* foundPVModel = new G4PhysicalVolumeModel
    (findings.fpFoundPV,
     requestedDepthOfDescent,
     findings.fFoundObjectTransformation,
     0, // No modelling parameters (these are set later by the scene handler).
     useFullExtent,
     findings.fFoundBasePVPath);
    if (clippingSolid) {
      foundPVModel->SetClippingSolid(clippingSolid);
      foundPVModel->SetClippingMode(clippingMode);
    }
    if (!foundPVModel->Validate(warn)) return;
    // ...so add it to the scene.
    G4bool successful = pScene->AddRunDurationModel(foundPVModel,warn);
    if (successful) {
      if (verbosity >= G4VisManager::confirmations) {
        G4cout << "\"" << findings.fpFoundPV->GetName()
        << "\", copy no. " << findings.fFoundPVCopyNo
        << ",\n  found in searched volume \""
        << findings.fpSearchPV->GetName()
        << "\" at depth " << findings.fFoundDepth
        << ",\n  base path: \"" << findings.fFoundBasePVPath
        << "\",\n  with a requested depth of further descent of ";
        if (requestedDepthOfDescent < 0) {
          G4cout << "<0 (unlimited)";
        }
        else {
          G4cout << requestedDepthOfDescent;
        }
        G4cout << ",\n  has been added to scene \"" << pScene->GetName() << "\"."
        << G4endl;
      }
    } else {
      G4VisCommandsSceneAddUnsuccessful(verbosity);
    }
  }
 
  if (findingsVector.empty()) {
    if (verbosity >= G4VisManager::errors) {
      G4cerr << "ERROR: Volume \"" << name << "\"";
      if (copyNo >= 0) {
        G4cerr << ", copy no. " << copyNo << ",";
      }
      G4cerr << " not found." << G4endl;
    }
    G4VisCommandsSceneAddUnsuccessful(verbosity);
    return;
  }
 
  CheckSceneAndNotifyHandlers(pScene);
}

References G4Scene::AddRunDurationModel(), G4VVisCommand::CheckSceneAndNotifyHandlers(), G4VisManager::confirmations, G4PhysicalVolumeModel::DescribeYourselfTo(), G4VisManager::errors, G4VVisCommand::fpVisManager, G4cerr, G4cout, G4endl, G4VVisCommand::G4VisCommandsSceneAddUnsuccessful(), G4VisManager::GetCurrentScene(), G4PhysicalVolumesSearchScene::GetFindings(), G4Scene::GetName(), G4TransportationManager::GetNoWorlds(), G4TransportationManager::GetTransportationManager(), G4VisManager::GetVerbosity(), G4TransportationManager::GetWorldsIterator(), G4PhysicalVolumeModel::intersection, G4InuclParticleNames::name(), G4PhysicalVolumeModel::SetClippingMode(), G4PhysicalVolumeModel::SetClippingSolid(), G4PhysicalVolumeModel::subtraction, G4PhysicalVolumeModel::UNLIMITED, G4PhysicalVolumeModel::Validate(), G4UIcommand::ValueOf(), G4VisManager::warnings, and G4InuclParticleNames::z0.

◆ SetViewParameters()

void G4VVisCommand::SetViewParameters	(	G4VViewer *	viewer,
		const G4ViewParameters &	viewParams
	)

protectedinherited

Definition at line 265 of file G4VVisCommand.cc.

                                                        {
  viewer->SetViewParameters(viewParams);
  RefreshIfRequired(viewer);
}

References G4VVisCommand::RefreshIfRequired(), and G4VViewer::SetViewParameters().

◆ SetVisManager()

void G4VVisCommand::SetVisManager ( G4VisManager * pVisManager )

staticinherited

Definition at line 65 of file G4VVisCommand.cc.

{
  fpVisManager = pVisManager;
}

References G4VVisCommand::fpVisManager.

Referenced by G4VisManager::G4VisManager().

◆ StoB()

G4bool G4UImessenger::StoB ( G4String s )

protectedinherited

Definition at line 137 of file G4UImessenger.cc.

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

References G4StrUtil::to_upper_copy().

Referenced by G4LocalThreadCoutMessenger::SetNewValue(), G4CascadeParamMessenger::SetNewValue(), G4ScoreQuantityMessenger::SetNewValue(), and G4ScoringMessenger::SetNewValue().

◆ StoD()

G4double G4UImessenger::StoD ( G4String s )

protectedinherited

Definition at line 127 of file G4UImessenger.cc.

{
  G4double vl;
  const char* t = str;
  std::istringstream is(t);
  is >> vl;
  return vl;
}

Referenced by G4ScoreQuantityMessenger::FParticleWithEnergyCommand(), G4ParticleGunMessenger::IonCommand(), G4GeneralParticleSourceMessenger::IonCommand(), G4UIcontrolMessenger::SetNewValue(), G4MatScanMessenger::SetNewValue(), G4VisCommandSceneAddText::SetNewValue(), G4VisCommandSceneAddText2D::SetNewValue(), G4ScoreQuantityMessenger::SetNewValue(), G4ScoringMessenger::SetNewValue(), and G4PolarizationMessenger::SetNewValue().

◆ StoI()

G4int G4UImessenger::StoI ( G4String s )

protectedinherited

Definition at line 107 of file G4UImessenger.cc.

{
  G4int vl;
  const char* t = str;
  std::istringstream is(t);
  is >> vl;
  return vl;
}

Referenced by G4ScoringMessenger::Fill1D(), G4ParticleGunMessenger::IonCommand(), G4GeneralParticleSourceMessenger::IonCommand(), G4ParticleGunMessenger::IonLevelCommand(), G4GeneralParticleSourceMessenger::IonLvlCommand(), G4ScoringMessenger::MeshBinCommand(), G4LocalThreadCoutMessenger::SetNewValue(), G4UIcontrolMessenger::SetNewValue(), G4MatScanMessenger::SetNewValue(), G4GMocrenMessenger::SetNewValue(), G4ScoreQuantityMessenger::SetNewValue(), and G4ScoringMessenger::SetNewValue().

◆ StoL()

G4long G4UImessenger::StoL ( G4String s )

protectedinherited

Definition at line 117 of file G4UImessenger.cc.

{
  G4long vl;
  const char* t = str;
  std::istringstream is(t);
  is >> vl;
  return vl;
}

Referenced by G4RunMessenger::SetNewValue().

Field Documentation

◆ baseDir

G4UIdirectory* G4UImessenger::baseDir = nullptr

protectedinherited

Definition at line 102 of file G4UImessenger.hh.

Referenced by G4UImessenger::CreateDirectory(), and G4UImessenger::~G4UImessenger().

◆ baseDirName

G4String G4UImessenger::baseDirName = ""

protectedinherited

Definition at line 103 of file G4UImessenger.hh.

Referenced by G4UImessenger::CreateCommand(), and G4UImessenger::CreateDirectory().

◆ commandsShouldBeInMaster

G4bool G4UImessenger::commandsShouldBeInMaster = false

protectedinherited

Definition at line 104 of file G4UImessenger.hh.

Referenced by G4UImessenger::CommandsShouldBeInMaster(), and G4GeneralParticleSourceMessenger::G4GeneralParticleSourceMessenger().

◆ fCurrentArrow3DLineSegmentsPerCircle

G4int G4VVisCommand::fCurrentArrow3DLineSegmentsPerCircle = 6

staticprotectedinherited

Definition at line 146 of file G4VVisCommand.hh.

Referenced by G4VisCommandSceneAddArrow::SetNewValue(), G4VisCommandSceneAddElectricField::SetNewValue(), G4VisCommandSceneAddMagneticField::SetNewValue(), and G4VisCommandSetArrow3DLineSegmentsPerCircle::SetNewValue().

◆ fCurrentColour

G4Colour G4VVisCommand::fCurrentColour = G4Colour::White()

staticprotectedinherited

Definition at line 147 of file G4VVisCommand.hh.

Referenced by G4VisCommandSceneAddArrow::SetNewValue(), G4VisCommandSceneAddArrow2D::SetNewValue(), G4VisCommandSceneAddFrame::SetNewValue(), G4VisCommandSceneAddLine::SetNewValue(), G4VisCommandSceneAddLine2D::SetNewValue(), and G4VisCommandSetColour::SetNewValue().

◆ fCurrentExtentForField

G4VisExtent G4VVisCommand::fCurrentExtentForField

staticprotectedinherited

Definition at line 156 of file G4VVisCommand.hh.

Referenced by G4VisCommandSceneAddElectricField::SetNewValue(), G4VisCommandSceneAddMagneticField::SetNewValue(), G4VisCommandSetExtentForField::SetNewValue(), G4VisCommandSetVolumeForField::SetNewValue(), and G4VisCommandsTouchable::SetNewValue().

◆ fCurrentLineWidth

G4double G4VVisCommand::fCurrentLineWidth = 1.

staticprotectedinherited

Definition at line 148 of file G4VVisCommand.hh.

Referenced by G4VisCommandSceneAddArrow::SetNewValue(), G4VisCommandSceneAddArrow2D::SetNewValue(), G4VisCommandSceneAddAxes::SetNewValue(), G4VisCommandSceneAddFrame::SetNewValue(), G4VisCommandSceneAddLine::SetNewValue(), G4VisCommandSceneAddLine2D::SetNewValue(), and G4VisCommandSetLineWidth::SetNewValue().

◆ fCurrentTextColour

G4Colour G4VVisCommand::fCurrentTextColour = G4Colour::Blue()

staticprotectedinherited

Definition at line 152 of file G4VVisCommand.hh.

Referenced by G4VVisCommand::GetCurrentTextColour(), G4VisCommandSceneAddText::SetNewValue(), G4VisCommandSceneAddText2D::SetNewValue(), and G4VisCommandSetTextColour::SetNewValue().

◆ fCurrentTextLayout

G4Text::Layout G4VVisCommand::fCurrentTextLayout = G4Text::left

staticprotectedinherited

Definition at line 153 of file G4VVisCommand.hh.

Referenced by G4VisCommandSceneAddText::SetNewValue(), G4VisCommandSceneAddText2D::SetNewValue(), and G4VisCommandSetTextLayout::SetNewValue().

◆ fCurrentTextSize

G4double G4VVisCommand::fCurrentTextSize = 12.

staticprotectedinherited

Definition at line 154 of file G4VVisCommand.hh.

Referenced by G4VisCommandSceneAddAxes::SetNewValue(), G4VisCommandSceneAddScale::SetNewValue(), and G4VisCommandSetTextSize::SetNewValue().

◆ fCurrentTouchableProperties

G4PhysicalVolumeModel::TouchableProperties G4VVisCommand::fCurrentTouchableProperties

staticprotectedinherited

Definition at line 155 of file G4VVisCommand.hh.

Referenced by G4VisCommandSetTouchable::SetNewValue(), G4VisCommandsTouchable::SetNewValue(), and G4VisCommandsTouchableSet::SetNewValue().

◆ fCurrrentPVFindingsForField

std::vector< G4PhysicalVolumesSearchScene::Findings > G4VVisCommand::fCurrrentPVFindingsForField

staticprotectedinherited

Definition at line 157 of file G4VVisCommand.hh.

Referenced by G4VisCommandSceneAddElectricField::SetNewValue(), G4VisCommandSceneAddMagneticField::SetNewValue(), G4VisCommandSetExtentForField::SetNewValue(), G4VisCommandSetVolumeForField::SetNewValue(), and G4VisCommandsTouchable::SetNewValue().

◆ fpCommand

G4UIcommand* G4VisCommandSceneAddVolume::fpCommand

private

Definition at line 488 of file G4VisCommandsSceneAdd.hh.

◆ fpVisManager

G4VisManager * G4VVisCommand::fpVisManager = nullptr

staticprotectedinherited

Definition at line 143 of file G4VVisCommand.hh.

◆ fThereWasAViewer

G4bool G4VVisCommand::fThereWasAViewer = false

staticprotectedinherited

Definition at line 163 of file G4VVisCommand.hh.

Referenced by G4VisCommandSceneHandlerCreate::SetNewValue(), and G4VisCommandViewerCreate::SetNewValue().

◆ fVPExistingViewer

G4ViewParameters G4VVisCommand::fVPExistingViewer

staticprotectedinherited

Definition at line 164 of file G4VVisCommand.hh.

Referenced by G4VisCommandSceneHandlerCreate::SetNewValue(), and G4VisCommandViewerCreate::SetNewValue().

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

source/visualization/management/include/G4VisCommandsSceneAdd.hh
source/visualization/management/src/G4VisCommandsSceneAdd.cc

Public Member Functions

Static Public Member Functions

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Static Protected Attributes

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ G4VisCommandSceneAddVolume() [1/2]

◆ ~G4VisCommandSceneAddVolume()

◆ G4VisCommandSceneAddVolume() [2/2]

Member Function Documentation

◆ AddUIcommand()

◆ BtoS()

◆ CheckSceneAndNotifyHandlers()

◆ CheckView()

◆ CommandsShouldBeInMaster()

◆ ConvertToColour()

◆ ConvertToColourGuidance()

◆ ConvertToDoublePair()

◆ ConvertToString()

◆ CopyCameraParameters()

◆ CopyGuidanceFrom()

◆ CopyMostViewParameters()

◆ CopyParametersFrom()

◆ CreateCommand()

◆ CreateDirectory()

◆ CurrentSceneName()

◆ DrawExtent()

◆ DtoS()

◆ G4VisCommandsSceneAddUnsuccessful()

◆ GetCurrentTextColour()

◆ GetCurrentValue()

◆ GetVisManager()

◆ InterpolateToNewView()

◆ InterpolateViews()

◆ ItoS()

◆ operator!=()

◆ operator=()

◆ operator==()

◆ ProvideValueOfUnit()

◆ RefreshIfRequired()

◆ SetNewValue()

◆ SetViewParameters()

◆ SetVisManager()

◆ StoB()

◆ StoD()

◆ StoI()

◆ StoL()

Field Documentation

◆ baseDir

◆ baseDirName

◆ commandsShouldBeInMaster

◆ fCurrentArrow3DLineSegmentsPerCircle

◆ fCurrentColour

◆ fCurrentExtentForField

◆ fCurrentLineWidth

◆ fCurrentTextColour

◆ fCurrentTextLayout

◆ fCurrentTextSize

◆ fCurrentTouchableProperties

◆ fCurrrentPVFindingsForField

◆ fpCommand

◆ fpVisManager

◆ fThereWasAViewer

◆ fVPExistingViewer