G4VisCommandViewerCentreOn Class Reference

#include <G4VisCommandsViewer.hh>

Inheritance diagram for G4VisCommandViewerCentreOn:

Public Member Functions
	G4VisCommandViewerCentreOn ()
virtual	~G4VisCommandViewerCentreOn ()
G4String	GetCurrentValue (G4UIcommand *command)
void	SetNewValue (G4UIcommand *command, G4String newValue)
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 G4VVisCommand
void	SetViewParameters (G4VViewer *viewer, const G4ViewParameters &viewParams)
void	RefreshIfRequired (G4VViewer *viewer)
void	InterpolateViews (G4VViewer *currentViewer, 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 (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 56 of file G4VisCommandsViewer.hh.

Constructor & Destructor Documentation

G4VisCommandViewerCentreOn()

G4VisCommandViewerCentreOn::G4VisCommandViewerCentreOn

(

)

Definition at line 142 of file G4VisCommandsViewer.cc.

                                                        {
  G4bool omitable;
  fpCommandCentreAndZoomInOn = new G4UIcommand ("/vis/viewer/centreAndZoomInOn", this);
  fpCommandCentreAndZoomInOn->SetGuidance
  ("Centre and zoom in on the given physical volume.");
  fpCommandCentreAndZoomInOn->SetGuidance
  ("The names of all volumes in all worlds are matched against pv-name. If"
   "\ncopy-no is supplied, it matches the copy number too. If pv-name is of the"
   "\nform \"/regexp/\", where regexp is a regular expression (see C++ regex),"
   "\nthe match uses the usual rules of regular expression matching."
   "\nOtherwise an exact match is required."
   "\nFor example, \"/Shap/\" matches \"Shape1\" and \"Shape2\".");
  fpCommandCentreAndZoomInOn->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.");
  fpCommandCentreAndZoomInOn->SetGuidance
   ("If there are more than one matching physical volumes they will all be"
    "\nincluded. If this is not what you want, and what you want is to centre on a"
    "\nparticular touchable, then select the touchable (\"/vis/set/touchable\") and"
    "\nuse \"/vis/touchable/centreOn\". (You may need \"/vis/touchable/findPath\".)");
  G4UIparameter* parameter;
  parameter =  new G4UIparameter("pv-name",'s',omitable = false);
  parameter->SetGuidance      ("Physical volume name.");
  fpCommandCentreAndZoomInOn->SetParameter(parameter);
  parameter =  new G4UIparameter("copy-no",'i',omitable = true);
  parameter->SetDefaultValue  (-1);
  parameter->SetGuidance      ("Copy number. -1 means any or all copy numbers");
  fpCommandCentreAndZoomInOn->SetParameter(parameter);
 
  fpCommandCentreOn = new G4UIcommand ("/vis/viewer/centreOn", this);
  fpCommandCentreOn->SetGuidance ("Centre the view on the given physical volume.");
  // Pick up additional guidance from /vis/viewer/centreAndZoomInOn
  CopyGuidanceFrom(fpCommandCentreAndZoomInOn,fpCommandCentreOn,1);
  // Pick up parameters from /vis/viewer/centreAndZoomInOn
  CopyParametersFrom(fpCommandCentreAndZoomInOn,fpCommandCentreOn);
}

~G4VisCommandViewerCentreOn()

G4VisCommandViewerCentreOn::~G4VisCommandViewerCentreOn ( )

virtual

Definition at line 180 of file G4VisCommandsViewer.cc.

                                                         {
  delete fpCommandCentreAndZoomInOn;
  delete fpCommandCentreOn;
}

Member Function Documentation

GetCurrentValue()

G4String G4VisCommandViewerCentreOn::GetCurrentValue ( G4UIcommand * command )

virtual

Reimplemented from G4UImessenger.

Definition at line 185 of file G4VisCommandsViewer.cc.

                                                                  {
  return "";
}

SetNewValue()

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

virtual

Reimplemented from G4UImessenger.

Definition at line 189 of file G4VisCommandsViewer.cc.

                                                                                     {
  
  G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
  G4bool warn = verbosity >= G4VisManager::warnings;
 
  G4VViewer* currentViewer = fpVisManager -> GetCurrentViewer ();
  if (!currentViewer) {
    if (verbosity >= G4VisManager::errors) {
      G4warn <<
      "ERROR: No current viewer - \"/vis/viewer/list\" to see possibilities."
      << G4endl;
    }
    return;
  }
  
  G4String pvName;
  G4int copyNo;
  std::istringstream is (newValue);
  is >> pvName >> copyNo;
 
  // Find physical volumes
  G4TransportationManager* transportationManager =
  G4TransportationManager::GetTransportationManager ();
  std::size_t nWorlds = transportationManager->GetNoWorlds();
  std::vector<G4PhysicalVolumesSearchScene::Findings> findingsVector;
  std::vector<G4VPhysicalVolume*>::iterator iterWorld =
  transportationManager->GetWorldsIterator();
  for (std::size_t i = 0; i < nWorlds; ++i, ++iterWorld) {
    G4PhysicalVolumeModel searchModel (*iterWorld);  // Unlimited depth.
    G4ModelingParameters mp;  // Default - no culling.
    searchModel.SetModelingParameters (&mp);
    // Find all instances at any position in the tree
    G4PhysicalVolumesSearchScene searchScene (&searchModel, pvName, copyNo);
    searchModel.DescribeYourselfTo (searchScene);  // Initiate search.
    for (const auto& findings: searchScene.GetFindings()) {
      findingsVector.push_back(findings);
    }
  }
  
  if (findingsVector.empty()) {
    if (verbosity >= G4VisManager::warnings) {
      G4warn
      << "WARNING: Volume \"" << pvName << "\" ";
      if (copyNo > 0) {
        G4warn << "copy number " << copyNo;
      }
      G4warn << " not found." << G4endl;
    }
    return;
  }
 
  // A vector of found paths so that we can highlight (twinkle) the found volume(s).
  std::vector<std::vector<G4PhysicalVolumeModel::G4PhysicalVolumeNodeID>> foundPaths;
 
  // Use a temporary scene in order to find vis extent
  G4Scene tempScene("Centre Scene");
  G4bool successfullyAdded = true;
  for (const auto& findings: findingsVector) {
    // To handle paramaterisations we have to set the copy number
    findings.fpFoundPV->SetCopyNo(findings.fFoundPVCopyNo);
    // Create a temporary physical volume model.
    // They have to be created on the heap because they have
    // to hang about long enough to be conflated.
    G4PhysicalVolumeModel* tempPVModel = new G4PhysicalVolumeModel
    (findings.fpFoundPV,
     0, // Only interested in top volume
     findings.fFoundObjectTransformation,
     0, // No modelling parameters (these are set later by the scene handler).
     true,  // Use full extent
     findings.fFoundBasePVPath);
    // ...and add it to the scene.
    auto successful = tempScene.AddRunDurationModel(tempPVModel,warn);
    if (!successful) {
      successfullyAdded = false;
      continue;
    }
    if (verbosity >= G4VisManager::parameters) {
      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  has been added to temporary scene \"" << tempScene.GetName() << "\"."
      << G4endl;
    }
    foundPaths.push_back(findings.fFoundFullPVPath);
  }
  // Delete temporary physical volume models
  for (const auto& sceneModel: tempScene.GetRunDurationModelList()) {
    delete sceneModel.fpModel;
  }
  if (!successfullyAdded) return;
 
  // Relevant results
  const G4VisExtent& newExtent = tempScene.GetExtent();
  const G4ThreeVector& newTargetPoint = newExtent.GetExtentCentre();
 
  G4Scene* currentScene = currentViewer->GetSceneHandler()->GetScene();
  G4ViewParameters saveVP = currentViewer->GetViewParameters();
  G4ViewParameters newVP = saveVP;
  if (command == fpCommandCentreAndZoomInOn) {
    // Calculate the new zoom factor
    const G4double zoomFactor
    = currentScene->GetExtent().GetExtentRadius()/newExtent.GetExtentRadius();
    newVP.SetZoomFactor(zoomFactor);
  }
  // Change the target point
  const G4Point3D& standardTargetPoint = currentScene->GetStandardTargetPoint();
  newVP.SetCurrentTargetPoint(newTargetPoint - standardTargetPoint);
 
  // If this particular view is simple enough
  if (currentViewer->GetKernelVisitElapsedTimeSeconds() < 0.1) {
    // Interpolate
    auto keepVisVerbosity = fpVisManager->GetVerbosity();
    fpVisManager->SetVerboseLevel(G4VisManager::errors);
    if (newVP != saveVP) InterpolateToNewView(currentViewer, saveVP, newVP);
    // ...and twinkle
    Twinkle(currentViewer,newVP,foundPaths);
    fpVisManager->SetVerboseLevel(keepVisVerbosity);
  }
 
  if (verbosity >= G4VisManager::confirmations) {
    G4cout
    << "Viewer \"" << currentViewer->GetName()
    << "\" centred ";
    if (fpCommandCentreAndZoomInOn) {
      G4cout << "and zoomed in";
    }
    G4cout << " on physical volume(s) \"" << pvName << '\"'
    << G4endl;
  }
 
  SetViewParameters(currentViewer, newVP);
}

---

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

• G4VisCommandsViewer.hh
• G4VisCommandsViewer.cc