#include <G4VisCommandsTouchable.hh>

Inheritance diagram for G4VisCommandsTouchable:

Public Member Functions
	G4VisCommandsTouchable ()

virtual	~G4VisCommandsTouchable ()

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 39 of file G4VisCommandsTouchable.hh.

Constructor & Destructor Documentation

◆ G4VisCommandsTouchable()

G4VisCommandsTouchable::G4VisCommandsTouchable ( )

Definition at line 46 of file G4VisCommandsTouchable.cc.

{
  G4bool omitable;
 
  fpCommandCentreAndZoomInOn = new G4UIcmdWithoutParameter("/vis/touchable/centreAndZoomInOn",this);
  fpCommandCentreAndZoomInOn->SetGuidance ("Centre and zoom in on the current touchable.");
  fpCommandCentreAndZoomInOn->SetGuidance
  ("Use \"/vis/set/touchable\" to set current touchable.");
  fpCommandCentreAndZoomInOn->SetGuidance
  ("You may also need \"/vis/touchable/findPath\".");
  fpCommandCentreAndZoomInOn->SetGuidance
  ("Use \"/vis/touchable/set\" to set attributes.");
 
  fpCommandCentreOn = new G4UIcmdWithoutParameter("/vis/touchable/centreOn",this);
  fpCommandCentreOn->SetGuidance ("Centre the view on the current touchable.");
  // Pick up additional guidance from /vis/viewer/centreAndZoomInOn
  CopyGuidanceFrom(fpCommandCentreAndZoomInOn,fpCommandCentreOn,1);
 
  fpCommandDraw = new G4UIcmdWithABool("/vis/touchable/draw",this);
  fpCommandDraw->SetGuidance("Draw touchable.");
  fpCommandDraw->SetGuidance
  ("If parameter == true, also draw extent as a white wireframe box.");
  // Pick up additional guidance from /vis/viewer/centreAndZoomInOn
  CopyGuidanceFrom(fpCommandCentreAndZoomInOn,fpCommandDraw,1);
  fpCommandDraw->SetParameterName("extent", omitable = true);
  fpCommandDraw->SetDefaultValue(false);
 
  fpCommandDump = new G4UIcmdWithoutParameter("/vis/touchable/dump",this);
  fpCommandDump->SetGuidance("Dump touchable attributes.");
  // Pick up additional guidance from /vis/viewer/centreAndZoomInOn
  CopyGuidanceFrom(fpCommandCentreAndZoomInOn,fpCommandDump,1);
 
  fpCommandExtentForField = new G4UIcmdWithABool("/vis/touchable/extentForField",this);
  fpCommandExtentForField->SetGuidance("Set extent for field.");
  fpCommandExtentForField->SetGuidance("If parameter == true, also draw.");
  // Pick up additional guidance from /vis/viewer/centreAndZoomInOn
  CopyGuidanceFrom(fpCommandCentreAndZoomInOn,fpCommandExtentForField,1);
  fpCommandExtentForField->SetParameterName("draw", omitable = true);
  fpCommandExtentForField->SetDefaultValue(false);
 
  fpCommandFindPath = new G4UIcommand("/vis/touchable/findPath",this);
  fpCommandFindPath->SetGuidance
  ("Prints the path to touchable and its logical volume mother"
   "\ngiven a physical volume name and copy no.");
  fpCommandFindPath -> SetGuidance
  ("A search of all worlds is made and all physical volume names are"
   "\nmatched against the argument of this command.  If this is of the"
   "\nform \"/regexp/\", where regexp is a regular expression (see C++ regex),"
   "\nthe physical volume name is matched against regexp by the usual rules"
   "\nof regular expression matching. Otherwise an exact match is required."
   "\nFor example, \"/Shap/\" matches \"Shape1\" and \"Shape2\".");
  fpCommandFindPath -> 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., HepRep.");
  G4UIparameter* parameter;
  parameter = new G4UIparameter ("physical-volume-name", 's', omitable = true);
  parameter -> SetDefaultValue ("world");
  fpCommandFindPath -> SetParameter (parameter);
  parameter = new G4UIparameter ("copy-no", 'i', omitable = true);
  parameter -> SetGuidance ("If negative, matches any copy no.");
  parameter -> SetDefaultValue (-1);
  fpCommandFindPath -> SetParameter (parameter);
 
  fpCommandLocalAxes = new G4UIcmdWithoutParameter("/vis/touchable/localAxes",this);
  fpCommandLocalAxes->SetGuidance("Draw local axes.");
  // Pick up additional guidance from /vis/viewer/centreAndZoomInOn
  CopyGuidanceFrom(fpCommandCentreAndZoomInOn,fpCommandLocalAxes,1);
 
  fpCommandShowExtent = new G4UIcmdWithABool("/vis/touchable/showExtent",this);
  fpCommandShowExtent->SetGuidance("Print extent of touchable.");
  fpCommandShowExtent->SetGuidance("If parameter == true, also draw.");
  // Pick up additional guidance from /vis/viewer/centreAndZoomInOn
  CopyGuidanceFrom(fpCommandCentreAndZoomInOn,fpCommandShowExtent,1);
  fpCommandShowExtent->SetParameterName("draw", omitable = true);
  fpCommandShowExtent->SetDefaultValue(false);
 
  fpCommandTwinkle = new G4UIcmdWithoutParameter("/vis/touchable/twinkle",this);
  fpCommandTwinkle->SetGuidance("Cause touchable to twinkle.");
  // Pick up additional guidance from /vis/viewer/centreAndZoomInOn
  CopyGuidanceFrom(fpCommandCentreAndZoomInOn,fpCommandTwinkle,1);
 
  fpCommandVolumeForField = new G4UIcmdWithABool("/vis/touchable/volumeForField",this);
  fpCommandVolumeForField->SetGuidance("Set volume for field.");
  fpCommandVolumeForField->SetGuidance("If parameter == true, also draw.");
  // Pick up additional guidance from /vis/viewer/centreAndZoomInOn
  CopyGuidanceFrom(fpCommandCentreAndZoomInOn,fpCommandVolumeForField,1);
  fpCommandVolumeForField->SetParameterName("draw", omitable = true);
  fpCommandVolumeForField->SetDefaultValue(false);
}

◆ ~G4VisCommandsTouchable()

G4VisCommandsTouchable::~G4VisCommandsTouchable ( )

virtual

Definition at line 137 of file G4VisCommandsTouchable.cc.

                                                {
  delete fpCommandVolumeForField;
  delete fpCommandTwinkle;
  delete fpCommandShowExtent;
  delete fpCommandLocalAxes;
  delete fpCommandFindPath;
  delete fpCommandExtentForField;
  delete fpCommandDump;
  delete fpCommandDraw;
  delete fpCommandCentreAndZoomInOn;
  delete fpCommandCentreOn;
}

Member Function Documentation

◆ GetCurrentValue()

G4String G4VisCommandsTouchable::GetCurrentValue ( G4UIcommand * command )

virtual

Reimplemented from G4UImessenger.

Definition at line 150 of file G4VisCommandsTouchable.cc.

                                                             {
  return "";
}

◆ SetNewValue()

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

virtual

Reimplemented from G4UImessenger.

Definition at line 154 of file G4VisCommandsTouchable.cc.

{
  G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
  G4bool warn = verbosity >= G4VisManager::warnings;
 
  G4UImanager* UImanager = G4UImanager::GetUIpointer();
 
  G4TransportationManager* transportationManager =
  G4TransportationManager::GetTransportationManager ();
 
  size_t nWorlds = transportationManager->GetNoWorlds();
 
  G4VPhysicalVolume* world = *(transportationManager->GetWorldsIterator());
  if (!world) {
    if (verbosity >= G4VisManager::errors) {
      G4warn <<
      "ERROR: G4VisCommandsTouchable::SetNewValue:"
      "\n  No world.  Maybe the geometry has not yet been defined."
      "\n  Try \"/run/initialize\""
      << G4endl;
    }
    return;
  }
 
  G4VViewer* currentViewer = fpVisManager -> GetCurrentViewer ();
  if (!currentViewer) {
    if (verbosity >= G4VisManager::errors) {
      G4warn <<
      "ERROR: No current viewer - \"/vis/viewer/list\" to see possibilities."
      << G4endl;
    }
    return;
  }
 
  G4Scene* currentScene = fpVisManager->GetCurrentScene();
  if (!currentScene) {
    if (verbosity >= G4VisManager::errors) {
      G4warn <<
      "ERROR: No current scene - \"/vis/scene/list\" to see possibilities."
      << G4endl;
    }
    return;
  }
 
  if (command == fpCommandCentreOn || command == fpCommandCentreAndZoomInOn) {
 
    // For twinkling...
    std::vector<std::vector<G4PhysicalVolumeModel::G4PhysicalVolumeNodeID>> touchables;
 
    G4PhysicalVolumeModel::TouchableProperties properties =
    G4TouchableUtils::FindTouchableProperties(fCurrentTouchableProperties.fTouchablePath);
    if (properties.fpTouchablePV) {
      // To handle parameterisations, set copy number
      properties.fpTouchablePV->SetCopyNo(properties.fCopyNo);
      G4PhysicalVolumeModel tempPVModel
      (properties.fpTouchablePV,
       G4PhysicalVolumeModel::UNLIMITED,
       properties.fTouchableGlobalTransform,
       nullptr, // Modelling parameters (not used)
       true, // use full extent (prevents calculating own extent, which crashes)
       properties.fTouchableBaseFullPVPath);
      touchables.push_back(properties.fTouchableFullPVPath);  // Only one in this case
      // Use a temporary scene in order to find vis extent
      G4Scene tempScene("Centre Scene");
      G4bool successful = tempScene.AddRunDurationModel(&tempPVModel,warn);
      if (!successful) return;
      if (verbosity >= G4VisManager::parameters) {
        G4cout
        << "Touchable " << fCurrentTouchableProperties.fTouchablePath
        << ",\n  has been added to temporary scene \"" << tempScene.GetName() << "\"."
        << G4endl;
      }
 
      const G4VisExtent& newExtent = tempScene.GetExtent();
      const G4ThreeVector& newTargetPoint = newExtent.GetExtentCentre();
      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);
 
      // Interpolate
      auto keepVisVerbose = fpVisManager->GetVerbosity();
      fpVisManager->SetVerboseLevel(G4VisManager::errors);
      if (newVP != saveVP) InterpolateToNewView(currentViewer, saveVP, newVP);
      // ...and twinkle
      Twinkle(currentViewer,newVP,touchables);
      fpVisManager->SetVerboseLevel(keepVisVerbose);
 
      if (verbosity >= G4VisManager::confirmations) {
        G4cout
        << "Viewer \"" << currentViewer->GetName()
        << "\" centred ";
        if (fpCommandCentreAndZoomInOn) {
          G4cout << "and zoomed in";
        }
        G4cout << " on touchable\n" << fCurrentTouchableProperties.fTouchablePath
        << G4endl;
      }
      SetViewParameters(currentViewer, newVP);
    } else {
      G4warn << "Touchable not found." << G4endl;
    }
    return;
    
  } else if (command == fpCommandDraw) {
 
    G4PhysicalVolumeModel::TouchableProperties properties =
    G4TouchableUtils::FindTouchableProperties(fCurrentTouchableProperties.fTouchablePath);
    if (properties.fpTouchablePV) {
      // To handle parameterisations we have to set the copy number
      properties.fpTouchablePV->SetCopyNo(properties.fCopyNo);
      G4PhysicalVolumeModel* pvModel = new G4PhysicalVolumeModel
      (properties.fpTouchablePV,
       G4PhysicalVolumeModel::UNLIMITED,
       properties.fTouchableGlobalTransform,
       nullptr, // Modelling parameters (not used)
       true, // use full extent (prevents calculating own extent, which crashes)
       properties.fTouchableBaseFullPVPath);
 
      UImanager->ApplyCommand("/vis/scene/create");
      currentScene = fpVisManager->GetCurrentScene();  // New current scene
      G4bool successful = currentScene->AddRunDurationModel(pvModel,warn);
      UImanager->ApplyCommand("/vis/sceneHandler/attach");
 
      if (successful) {
        if (fpCommandDraw->GetNewBoolValue(newValue)) {
          const auto& extent = pvModel->GetExtent();
          const G4double halfX = (extent.GetXmax()-extent.GetXmin())/2.;
          const G4double halfY = (extent.GetYmax()-extent.GetYmin())/2.;
          const G4double halfZ = (extent.GetZmax()-extent.GetZmin())/2.;
          G4Box extentBox("extent",halfX,halfY,halfZ);
          G4VisAttributes extentVA;
          extentVA.SetForceWireframe();
          fpVisManager->Draw(extentBox,extentVA,G4Translate3D(extent.GetExtentCentre()));
        }
        if (verbosity >= G4VisManager::confirmations) {
          G4cout << "\"" << properties.fpTouchablePV->GetName()
          << "\", copy no. " << properties.fCopyNo << " drawn";
          if (fpCommandDraw->GetNewBoolValue(newValue)) {
            G4cout << " with extent box";
          }
          G4cout << '.' << G4endl;
        }
      } else {
        G4VisCommandsSceneAddUnsuccessful(verbosity);
      }
    } else {
      G4warn << "Touchable not found." << G4endl;
    }
    return;
 
  } else if (command == fpCommandDump) {
 
    G4PhysicalVolumeModel::TouchableProperties properties =
    G4TouchableUtils::FindTouchableProperties(fCurrentTouchableProperties.fTouchablePath);
    if (properties.fpTouchablePV) {
      // To handle parameterisations we have to set the copy number
      properties.fpTouchablePV->SetCopyNo(properties.fCopyNo);
      G4PhysicalVolumeModel tempPVModel
      (properties.fpTouchablePV,
       G4PhysicalVolumeModel::UNLIMITED,
       properties.fTouchableGlobalTransform,
       nullptr, // Modelling parameters (not used)
       true, // use full extent (prevents calculating own extent, which crashes)
       properties.fTouchableBaseFullPVPath);
      const std::map<G4String,G4AttDef>* attDefs = tempPVModel.GetAttDefs();
      std::vector<G4AttValue>* attValues = tempPVModel.CreateCurrentAttValues();
      G4cout << G4AttCheck(attValues,attDefs);
      delete attValues;
      const auto lv = properties.fpTouchablePV->GetLogicalVolume();
      const auto polyhedron = lv->GetSolid()->GetPolyhedron();
      polyhedron->SetVisAttributes(lv->GetVisAttributes());
      G4cout << "\nLocal polyhedron coordinates:\n" << *polyhedron;
      const G4Transform3D& transform = tempPVModel.GetCurrentTransform();
      polyhedron->Transform(transform);
      G4cout << "\nGlobal polyhedron coordinates:\n" << *polyhedron;
    } else {
      G4warn << "Touchable not found." << G4endl;
    }
    return;
 
  } else if (command == fpCommandExtentForField) {
 
    G4PhysicalVolumeModel::TouchableProperties properties =
    G4TouchableUtils::FindTouchableProperties(fCurrentTouchableProperties.fTouchablePath);
    if (properties.fpTouchablePV) {
      G4VisExtent extent
      = properties.fpTouchablePV->GetLogicalVolume()->GetSolid()->GetExtent();
      extent.Transform(properties.fTouchableGlobalTransform);
      fCurrentExtentForField = extent;
      fCurrrentPVFindingsForField.clear();
      if (verbosity >= G4VisManager::confirmations) {
        G4cout << "Extent for field set to " << extent
        << "\nVolume for field has been cleared."
        << G4endl;
      }
      if (fpCommandExtentForField->GetNewBoolValue(newValue)) {
        DrawExtent(extent);
      }
    } else {
      G4warn << "Touchable not found." << G4endl;
    }
    return;
 
  } else if (command == fpCommandFindPath) {
 
    G4String pvName;
    G4int copyNo;
    std::istringstream iss(newValue);
    iss >> pvName >> copyNo;
    std::vector<G4PhysicalVolumesSearchScene::Findings> findingsVector;
    std::vector<G4VPhysicalVolume*>::iterator iterWorld =
    transportationManager->GetWorldsIterator();
    for (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);
      }
    }
    for (const auto& findings: findingsVector) {
      G4cout
      <<  findings.fFoundBasePVPath
      << ' ' << findings.fpFoundPV->GetName()
      << ' ' <<  findings.fFoundPVCopyNo
      << " (mother logical volume: "
      << findings.fpFoundPV->GetMotherLogical()->GetName()
      << ')'
      << G4endl;
    }
    if (findingsVector.size()) {
      G4cout
      << "Use this to set a particular touchable with \"/vis/set/touchable <path>\""
      << "\nor to see overlaps: \"/vis/drawLogicalVolume <mother-logical-volume-name>\""
      << G4endl;
    } else {
      G4warn << pvName;
      if (copyNo >= 0) G4warn << ':' << copyNo;
      G4warn << " not found" << G4endl;
    }
    return;
 
  } else if (command == fpCommandLocalAxes) {
 
    G4PhysicalVolumeModel::TouchableProperties properties =
    G4TouchableUtils::FindTouchableProperties(fCurrentTouchableProperties.fTouchablePath);
    if (properties.fpTouchablePV) {
      const auto& transform = fCurrentTouchableProperties.fTouchableGlobalTransform;
      const auto& extent = fCurrentTouchableProperties.fpTouchablePV->GetLogicalVolume()->GetSolid()->GetExtent();
      const G4double lengthMax = extent.GetExtentRadius()/2.;
      const G4double intLog10LengthMax = std::floor(std::log10(lengthMax));
      G4double length = std::pow(10,intLog10LengthMax);
      if (5.*length < lengthMax) length *= 5.;
      else if (2.*length < lengthMax) length *= 2.;
      G4AxesModel axesModel(0.,0.,0.,length,transform);
      axesModel.SetGlobalTag("LocalAxesModel");
      axesModel.DescribeYourselfTo(*fpVisManager->GetCurrentSceneHandler());
      G4UImanager::GetUIpointer()->ApplyCommand("/vis/viewer/refresh");
    } else {
      G4warn << "Touchable not found." << G4endl;
    }
    return;
 
  } else if (command == fpCommandShowExtent) {
 
    G4PhysicalVolumeModel::TouchableProperties properties =
    G4TouchableUtils::FindTouchableProperties(fCurrentTouchableProperties.fTouchablePath);
    if (properties.fpTouchablePV) {
      G4VisExtent extent
      = properties.fpTouchablePV->GetLogicalVolume()->GetSolid()->GetExtent();
      extent.Transform(properties.fTouchableGlobalTransform);
      G4cout << extent << G4endl;
      if (fpCommandShowExtent->GetNewBoolValue(newValue)) DrawExtent(extent);
    } else {
      G4warn << "Touchable not found." << G4endl;
    }
    return;
 
  } else if (command == fpCommandTwinkle) {
 
    G4PhysicalVolumeModel::TouchableProperties properties =
    G4TouchableUtils::FindTouchableProperties(fCurrentTouchableProperties.fTouchablePath);
    if (properties.fpTouchablePV) {
      std::vector<std::vector<G4PhysicalVolumeModel::G4PhysicalVolumeNodeID>> touchables;
      touchables.push_back(properties.fTouchableFullPVPath);
      auto keepVisVerbose = fpVisManager->GetVerbosity();
      fpVisManager->SetVerboseLevel(G4VisManager::errors);
      auto keepVP = currentViewer->GetViewParameters();
      Twinkle(currentViewer,currentViewer->GetViewParameters(),touchables);
      SetViewParameters(currentViewer, keepVP);
      fpVisManager->SetVerboseLevel(keepVisVerbose);
    } else {
      G4warn << "Touchable not found." << G4endl;
    }
    return;
 
  } else if (command == fpCommandVolumeForField) {
 
    G4PhysicalVolumeModel::TouchableProperties properties =
    G4TouchableUtils::FindTouchableProperties(fCurrentTouchableProperties.fTouchablePath);
    if (properties.fpTouchablePV) {
      G4VisExtent extent
      = properties.fpTouchablePV->GetLogicalVolume()->GetSolid()->GetExtent();
      extent.Transform(properties.fTouchableGlobalTransform);
      fCurrentExtentForField = extent;
      fCurrrentPVFindingsForField.clear();
      fCurrrentPVFindingsForField.push_back
      (G4PhysicalVolumesSearchScene::Findings(properties));
      if (verbosity >= G4VisManager::confirmations) {
        G4cout
        << "Volume for field set to " << properties.fpTouchablePV->GetName()
        << ':' << properties.fCopyNo
        << " at " << properties.fTouchableBaseFullPVPath
        << G4endl;
      }
      if (fpCommandVolumeForField->GetNewBoolValue(newValue)) {
        DrawExtent(extent);
      }
    } else {
      G4warn << "Touchable not found." << G4endl;
    }
    return;
 
  } else {
 
    if (verbosity >= G4VisManager::errors) {
      G4warn <<
      "ERROR: G4VisCommandsTouchable::SetNewValue: unrecognised command."
      << G4endl;
    }
    return;
  }
}

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

Public Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ G4VisCommandsTouchable()

◆ ~G4VisCommandsTouchable()

Member Function Documentation

◆ GetCurrentValue()

◆ SetNewValue()