G4VisCommandSceneAddVolume Class Reference

#include <G4VisCommandsSceneAdd.hh>

Inheritance diagram for G4VisCommandSceneAddVolume:

Public Member Functions
	G4VisCommandSceneAddVolume ()
virtual	~G4VisCommandSceneAddVolume ()
G4String	GetCurrentValue (G4UIcommand *command)
void	SetNewValue (G4UIcommand *command, G4String newValue)
Public Member Functions inherited from G4VVisCommandScene
	G4VVisCommandScene ()
virtual	~G4VVisCommandScene ()
Public Member Functions inherited from G4VVisCommand
	G4VVisCommand ()
virtual	~G4VVisCommand ()
Public Member Functions inherited from G4UImessenger
	G4UImessenger ()=default
	G4UImessenger (const G4String &path, const G4String &dsc, G4bool commandsToBeBroadcasted=true)
virtual	~G4UImessenger ()
G4bool	CommandsShouldBeInMaster () const

Additional Inherited Members
Static Public Member Functions inherited from G4VVisCommand
static G4VisManager *	GetVisManager ()
static void	SetVisManager (G4VisManager *pVisManager)
static const G4Colour &	GetCurrentTextColour ()
Protected Member Functions inherited from G4VVisCommandScene
G4String	CurrentSceneName ()
Protected Member Functions inherited from G4VVisCommand
void	SetViewParameters (G4VViewer *viewer, const G4ViewParameters &viewParams)
void	RefreshIfRequired (G4VViewer *viewer)
void	InterpolateViews (G4VViewer *currentViewer, const std::vector< G4ViewParameters > &viewVector, const G4int nInterpolationPoints=50, const G4int waitTimePerPointmilliseconds=20, const G4String &exportString="")
void	InterpolateToNewView (G4VViewer *currentViewer, const G4ViewParameters &oldVP, const G4ViewParameters &newVP, const G4int nInterpolationPoints=50, const G4int waitTimePerPointmilliseconds=20, const G4String &exportString="")
void	Twinkle (G4VViewer *currentViewer, const G4ViewParameters &baseVP, const std::vector< std::vector< G4PhysicalVolumeModel::G4PhysicalVolumeNodeID > > &paths)
const G4String &	ConvertToColourGuidance ()
void	ConvertToColour (G4Colour &colour, const G4String &redOrString, G4double green, G4double blue, G4double opacity)
G4bool	ProvideValueOfUnit (const G4String &where, const G4String &unit, const G4String &category, G4double &value)
void	CopyCameraParameters (G4ViewParameters &target, const G4ViewParameters &from)
void	CheckSceneAndNotifyHandlers (G4Scene *=nullptr)
G4bool	CheckView ()
void	G4VisCommandsSceneAddUnsuccessful (G4VisManager::Verbosity verbosity)
void	CopyGuidanceFrom (const G4UIcommand *fromCmd, G4UIcommand *toCmd, G4int startLine=0)
void	CopyParametersFrom (const G4UIcommand *fromCmd, G4UIcommand *toCmd)
void	DrawExtent (const G4VisExtent &)
Protected Member Functions inherited from G4UImessenger
G4String	ItoS (G4int i)
G4String	LtoS (G4long l)
G4String	DtoS (G4double a)
G4String	BtoS (G4bool b)
G4int	StoI (const G4String &s)
G4long	StoL (const G4String &s)
G4double	StoD (const G4String &s)
G4bool	StoB (const G4String &s)
void	AddUIcommand (G4UIcommand *newCommand)
void	CreateDirectory (const G4String &path, const G4String &dsc, G4bool commandsToBeBroadcasted=true)
template<typename T>
T *	CreateCommand (const G4String &cname, const G4String &dsc)
Static Protected Member Functions inherited from G4VVisCommand
static G4String	ConvertToString (G4double x, G4double y, const char *unitName)
static G4bool	ConvertToDoublePair (const G4String &paramString, G4double &xval, G4double &yval)
Protected Attributes inherited from G4UImessenger
G4UIdirectory *	baseDir = nullptr
G4String	baseDirName = ""
G4bool	commandsShouldBeInMaster = false
Static Protected Attributes inherited from G4VVisCommand
static G4VisManager *	fpVisManager = nullptr
static G4int	fCurrentArrow3DLineSegmentsPerCircle = 6
static G4Colour	fCurrentColour = G4Colour::White()
static G4double	fCurrentLineWidth = 1.
static G4Colour	fCurrentTextColour = G4Colour::Blue()
static G4Text::Layout	fCurrentTextLayout = G4Text::left
static G4double	fCurrentTextSize = 12.
static G4PhysicalVolumeModel::TouchableProperties	fCurrentTouchableProperties
static G4VisExtent	fCurrentExtentForField
static std::vector< G4PhysicalVolumesSearchScene::Findings >	fCurrrentPVFindingsForField
static G4bool	fThereWasAViewer = false
static G4ViewParameters	fExistingVP
static G4SceneTreeItem	fExistingSceneTree

Detailed Description

Definition at line 479 of file G4VisCommandsSceneAdd.hh.

Constructor & Destructor Documentation

G4VisCommandSceneAddVolume()

G4VisCommandSceneAddVolume::G4VisCommandSceneAddVolume

(

)

Definition at line 3042 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 (G4PhysicalVolumeModel::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);
}

~G4VisCommandSceneAddVolume()

G4VisCommandSceneAddVolume::~G4VisCommandSceneAddVolume ( )

virtual

Definition at line 3119 of file G4VisCommandsSceneAdd.cc.

                                                         {
  delete fpCommand;
}

Member Function Documentation

GetCurrentValue()

G4String G4VisCommandSceneAddVolume::GetCurrentValue ( G4UIcommand * command )

virtual

Reimplemented from G4UImessenger.

Definition at line 3123 of file G4VisCommandsSceneAdd.cc.

                                                                  {
  return "world 0 -1";
}

SetNewValue()

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

virtual

Reimplemented from G4UImessenger.

Definition at line 3127 of file G4VisCommandsSceneAdd.cc.

                                             {
 
  G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
  G4bool warn = verbosity >= G4VisManager::warnings;
 
  G4Scene* pScene = fpVisManager->GetCurrentScene();
  if (!pScene) {
    if (verbosity >= G4VisManager::errors) {
      G4warn <<   "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") {
    G4warn <<
      "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) {
      G4warn << "  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) {
      G4warn <<
    "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) {
    G4warn <<
      "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,
       requestedDepthOfDescent,
       G4Transform3D(),
       &mp,
       useFullExtent);
      G4PhysicalVolumesSearchScene searchScene(&searchModel, name, copyNo);
      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) {
      G4warn << "ERROR: Volume \"" << name << "\"";
      if (copyNo >= 0) {
        G4warn << ", copy no. " << copyNo << ",";
      }
      G4warn << " not found." << G4endl;
    }
    G4VisCommandsSceneAddUnsuccessful(verbosity);
    return;
  }
 
  CheckSceneAndNotifyHandlers(pScene);
}

---

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

• G4VisCommandsSceneAdd.hh
• G4VisCommandsSceneAdd.cc