#include <G4ASCIITreeSceneHandler.hh>

Inheritance diagram for G4ASCIITreeSceneHandler:

Public Member Functions
	G4ASCIITreeSceneHandler (G4VGraphicsSystem &system, const G4String &name)

virtual	~G4ASCIITreeSceneHandler ()

virtual void	BeginModeling ()

virtual void	EndModeling ()

Public Member Functions inherited from G4VTreeSceneHandler
	G4VTreeSceneHandler (G4VGraphicsSystem &system, const G4String &name)

virtual	~G4VTreeSceneHandler ()

void	PreAddSolid (const G4Transform3D &objectTransformation, const G4VisAttributes &)

void	PostAddSolid ()

virtual void	AddPrimitive (const G4Polyline &)

virtual void	AddPrimitive (const G4Text &)

virtual void	AddPrimitive (const G4Circle &)

virtual void	AddPrimitive (const G4Square &)

virtual void	AddPrimitive (const G4Polyhedron &)

virtual void	AddPrimitive (const G4Polymarker &)

virtual void	AddPrimitive (const G4Scale &)

Public Member Functions inherited from G4VSceneHandler
	G4VSceneHandler (G4VGraphicsSystem &system, G4int id, const G4String &name="")

virtual	~G4VSceneHandler ()

virtual void	AddSolid (const G4Box &)

virtual void	AddSolid (const G4Cons &)

virtual void	AddSolid (const G4Tubs &)

virtual void	AddSolid (const G4Trd &)

virtual void	AddSolid (const G4Trap &)

virtual void	AddSolid (const G4Sphere &)

virtual void	AddSolid (const G4Para &)

virtual void	AddSolid (const G4Torus &)

virtual void	AddSolid (const G4Polycone &)

virtual void	AddSolid (const G4Polyhedra &)

virtual void	AddSolid (const G4VSolid &)

virtual void	AddCompound (const G4VTrajectory &)

virtual void	AddCompound (const G4VHit &)

virtual void	AddCompound (const G4VDigi &)

virtual void	AddCompound (const G4THitsMap< G4double > &)

virtual void	BeginPrimitives (const G4Transform3D &objectTransformation)

virtual void	EndPrimitives ()

virtual void	BeginPrimitives2D (const G4Transform3D &objectTransformation)

virtual void	EndPrimitives2D ()

virtual const G4VisExtent &	GetExtent () const

const G4String &	GetName () const

G4int	GetSceneHandlerId () const

G4int	GetViewCount () const

G4VGraphicsSystem *	GetGraphicsSystem () const

G4Scene *	GetScene () const

const G4ViewerList &	GetViewerList () const

G4VModel *	GetModel () const

G4VViewer *	GetCurrentViewer () const

G4bool	GetMarkForClearingTransientStore () const

G4bool	IsReadyForTransients () const

G4bool	GetTransientsDrawnThisEvent () const

G4bool	GetTransientsDrawnThisRun () const

const G4Transform3D &	GetObjectTransformation () const

void	SetName (const G4String &)

void	SetCurrentViewer (G4VViewer *)

virtual void	SetScene (G4Scene *)

G4ViewerList &	SetViewerList ()

void	SetModel (G4VModel *)

void	SetMarkForClearingTransientStore (G4bool)

void	SetTransientsDrawnThisEvent (G4bool)

void	SetTransientsDrawnThisRun (G4bool)

void	SetObjectTransformation (const G4Transform3D &)

const G4Colour &	GetColour (const G4Visible &)

const G4Colour &	GetColor (const G4Visible &)

const G4Colour &	GetTextColour (const G4Text &)

const G4Colour &	GetTextColor (const G4Text &)

G4double	GetLineWidth (const G4VisAttributes *)

G4ViewParameters::DrawingStyle	GetDrawingStyle (const G4VisAttributes *)

G4bool	GetAuxEdgeVisible (const G4VisAttributes *)

G4int	GetNoOfSides (const G4VisAttributes *)

G4double	GetMarkerSize (const G4VMarker &, MarkerSizeType &)

G4double	GetMarkerDiameter (const G4VMarker &, MarkerSizeType &)

G4double	GetMarkerRadius (const G4VMarker &, MarkerSizeType &)

G4ModelingParameters *	CreateModelingParameters ()

void	DrawEvent (const G4Event *)

void	DrawEndOfRunModels ()

G4int	IncrementViewCount ()

virtual void	ClearStore ()

virtual void	ClearTransientStore ()

void	AddViewerToList (G4VViewer *pView)

void	RemoveViewerFromList (G4VViewer *pView)

Public Member Functions inherited from G4VGraphicsScene
	G4VGraphicsScene ()

virtual	~G4VGraphicsScene ()

Protected Types
typedef std::set < G4LogicalVolume * > ::iterator	LVSetIterator

typedef G4PhysicalVolumeModel::G4PhysicalVolumeNodeID	PVNodeID

typedef std::vector< PVNodeID >	PVPath

typedef std::set< PVPath > ::iterator	ReplicaSetIterator

typedef std::set< PVPath > ::reverse_iterator	ReplicaSetReverseIterator

Protected Member Functions
virtual void	RequestPrimitives (const G4VSolid &)

void	WriteHeader (std::ostream &)

Protected Member Functions inherited from G4VSceneHandler
virtual void	ProcessScene ()

virtual G4VSolid *	CreateSectionSolid ()

virtual G4VSolid *	CreateCutawaySolid ()

void	LoadAtts (const G4Visible &, G4AttHolder *)

Protected Attributes
std::ostream *	fpOutFile

std::ofstream	fOutFile

std::ostringstream	fRestOfLine

const G4VPhysicalVolume *	fpLastPV

G4String	fLastPVName

G4int	fLastCopyNo

G4int	fLastNonSequentialCopyNo

std::set< G4LogicalVolume * >	fLVSet

std::set< PVPath >	fReplicaSet

Protected Attributes inherited from G4VTreeSceneHandler
const G4Transform3D *	fpCurrentObjectTransformation

std::set< G4LogicalVolume * >	fDrawnLVStore

Protected Attributes inherited from G4VSceneHandler
G4VGraphicsSystem &	fSystem

const G4int	fSceneHandlerId

G4String	fName

G4int	fViewCount

G4ViewerList	fViewerList

G4VViewer *	fpViewer

G4Scene *	fpScene

G4bool	fMarkForClearingTransientStore

G4bool	fReadyForTransients

G4bool	fTransientsDrawnThisEvent

G4bool	fTransientsDrawnThisRun

G4bool	fProcessingSolid

G4bool	fProcessing2D

G4VModel *	fpModel

G4Transform3D	fObjectTransformation

G4int	fNestingDepth

const G4VisAttributes *	fpVisAttribs

const G4Transform3D	fIdentityTransformation

Additional Inherited Members
Public Types inherited from G4VSceneHandler
enum	MarkerSizeType { world, screen }

Static Protected Attributes inherited from G4VTreeSceneHandler
static G4int	fSceneIdCount = 0

Detailed Description

Definition at line 48 of file G4ASCIITreeSceneHandler.hh.

Member Typedef Documentation

typedef std::set<G4LogicalVolume*>::iterator G4ASCIITreeSceneHandler::LVSetIterator

protected

Definition at line 73 of file G4ASCIITreeSceneHandler.hh.

typedef G4PhysicalVolumeModel::G4PhysicalVolumeNodeID G4ASCIITreeSceneHandler::PVNodeID

protected

Definition at line 74 of file G4ASCIITreeSceneHandler.hh.

typedef std::vector<PVNodeID> G4ASCIITreeSceneHandler::PVPath

protected

Definition at line 75 of file G4ASCIITreeSceneHandler.hh.

typedef std::set<PVPath>::iterator G4ASCIITreeSceneHandler::ReplicaSetIterator

protected

Definition at line 77 of file G4ASCIITreeSceneHandler.hh.

typedef std::set<PVPath>::reverse_iterator G4ASCIITreeSceneHandler::ReplicaSetReverseIterator

protected

Definition at line 78 of file G4ASCIITreeSceneHandler.hh.

Constructor & Destructor Documentation

G4ASCIITreeSceneHandler::G4ASCIITreeSceneHandler	(	G4VGraphicsSystem &	system,
		const G4String &	name
	)

Definition at line 54 of file G4ASCIITreeSceneHandler.cc.

                       :
   G4VTreeSceneHandler(system, name),
   fpOutFile(0),
   fpLastPV(0),
   fLastCopyNo(-99),
   fLastNonSequentialCopyNo(-99)
 {}

G4ASCIITreeSceneHandler::~G4ASCIITreeSceneHandler ( )

virtual

Definition at line 63 of file G4ASCIITreeSceneHandler.cc.

63 {}

Member Function Documentation

void G4ASCIITreeSceneHandler::BeginModeling ( )

virtual

Reimplemented from G4VTreeSceneHandler.

Definition at line 65 of file G4ASCIITreeSceneHandler.cc.

References G4VTreeSceneHandler::BeginModeling(), fOutFile, fpOutFile, G4cout, G4endl, G4VSceneHandler::GetGraphicsSystem(), and WriteHeader().

                                              {
 
   G4VTreeSceneHandler::BeginModeling ();  // To re-use "culling off" code.
 
   const G4ASCIITree* pSystem = (G4ASCIITree*)GetGraphicsSystem();
   const G4String& outFileName = pSystem -> GetOutFileName();
   if (outFileName == "G4cout") {
     fpOutFile = &G4cout;
   } else {
     fOutFile.open (outFileName);
     fpOutFile = &fOutFile;
   }
 
   G4cout << "G4ASCIITreeSceneHandler::BeginModeling: writing to ";
   if (outFileName == "G4cout") {
     G4cout << "G4 standard output (G4cout)";
   } else {
     G4cout << "file \"" << outFileName << "\"";
   }
   G4cout << G4endl;
 
   WriteHeader (G4cout); G4cout << G4endl;
   if (outFileName != "G4cout") {
     WriteHeader (fOutFile); fOutFile << std::endl;
   }
 }

void G4ASCIITreeSceneHandler::EndModeling ( )

virtual

Reimplemented from G4VTreeSceneHandler.

Definition at line 113 of file G4ASCIITreeSceneHandler.cc.

References G4PhysicalVolumeModel::DescribeYourselfTo(), G4VTreeSceneHandler::EndModeling(), fLastCopyNo, fLastNonSequentialCopyNo, fLastPVName, fLVSet, fOutFile, fpLastPV, fpOutFile, G4VSceneHandler::fpScene, fReplicaSet, fRestOfLine, G4BestUnit, G4cout, G4endl, G4VPhysicalVolume::GetCopyNo(), G4VSceneHandler::GetGraphicsSystem(), G4PhysicalVolumeMassScene::GetMass(), G4VModel::GetModelingParameters(), G4VPhysicalVolume::GetName(), G4TransportationManager::GetNavigatorForTracking(), G4PhysicalVolumeModel::GetRequestedDepth(), G4Scene::GetRunDurationModelList(), G4PhysicalVolumeModel::GetTopPhysicalVolume(), G4TransportationManager::GetTransportationManager(), G4ASCIITree::GetVerbosity(), G4PhysicalVolumeMassScene::GetVolume(), G4Navigator::GetWorldVolume(), G4VModel::SetModelingParameters(), and G4PhysicalVolumeModel::UNLIMITED.

                                            {
   const G4ASCIITree* pSystem = (G4ASCIITree*) GetGraphicsSystem();
   const G4int verbosity = pSystem->GetVerbosity();
   const G4int detail = verbosity % 10;
   const G4String& outFileName = pSystem -> GetOutFileName();
 
   // Output left over copy number, if any...
   if (fLastCopyNo != fLastNonSequentialCopyNo) {
     if (fLastCopyNo == fLastNonSequentialCopyNo + 1) *fpOutFile << ',';
     else *fpOutFile << '-';
     *fpOutFile << fLastCopyNo;
   }
   // Output outstanding rest of line, if any...
   if (!fRestOfLine.str().empty()) *fpOutFile << fRestOfLine.str();
   fRestOfLine.str("");
   fpLastPV = 0;
   fLastPVName.clear();
   fLastCopyNo = -99;
   fLastNonSequentialCopyNo = -99;
 
   // This detail to G4cout regardless of outFileName...
   if (detail >= 4) {
     G4cout << "Calculating mass(es)..." << G4endl;
     const std::vector<G4Scene::Model>& models = fpScene->GetRunDurationModelList();
     std::vector<G4Scene::Model>::const_iterator i;
     for (i = models.begin(); i != models.end(); ++i) {
       G4PhysicalVolumeModel* pvModel =
     dynamic_cast<G4PhysicalVolumeModel*>(i->fpModel);
       if (pvModel) {
     if (pvModel->GetTopPhysicalVolume() ==
         G4TransportationManager::GetTransportationManager()
         ->GetNavigatorForTracking()->GetWorldVolume()) {
       const G4ModelingParameters* tempMP =
         pvModel->GetModelingParameters();
       G4ModelingParameters mp;  // Default - no culling.
       pvModel->SetModelingParameters (&mp);
       G4PhysicalVolumeMassScene massScene(pvModel);
       pvModel->DescribeYourselfTo (massScene);
       G4double volume = massScene.GetVolume();
       G4double mass = massScene.GetMass();
 
       G4cout << "Overall volume of \""
          << pvModel->GetTopPhysicalVolume()->GetName()
          << "\":"
          << pvModel->GetTopPhysicalVolume()->GetCopyNo()
          << ", is "
          << G4BestUnit (volume, "Volume")
          << " and the daughter-included mass";
       G4int requestedDepth = pvModel->GetRequestedDepth();
       if (requestedDepth == G4PhysicalVolumeModel::UNLIMITED) {
         G4cout << " to unlimited depth";
       } else {
         G4cout << ", ignoring daughters at depth "
            << requestedDepth
            << " and below,";
       }
       G4cout << " is " << G4BestUnit (mass, "Mass")
          << G4endl;
 
       pvModel->SetModelingParameters (tempMP);
     }
       }
     }
   }
 
   if (outFileName != "G4cout") {
     fOutFile.close();
     G4cout << "Output file \"" << outFileName << "\" closed." << G4endl;
   }
   fLVSet.clear();
   fReplicaSet.clear();
   G4cout << "G4ASCIITreeSceneHandler::EndModeling" << G4endl;
   G4VTreeSceneHandler::EndModeling ();  // To re-use "culling off" code.
 }

void G4ASCIITreeSceneHandler::RequestPrimitives ( const G4VSolid & solid )

protectedvirtual

Reimplemented from G4VSceneHandler.

Definition at line 188 of file G4ASCIITreeSceneHandler.cc.

References G4PhysicalVolumeModel::CurtailDescent(), fLastCopyNo, fLastNonSequentialCopyNo, fLastPVName, fLVSet, fpLastPV, G4VSceneHandler::fpModel, fpOutFile, fReplicaSet, fRestOfLine, G4BestUnit, G4Exception(), G4VPhysicalVolume::GetCopyNo(), G4PhysicalVolumeModel::GetCurrentLV(), G4PhysicalVolumeModel::GetCurrentMaterial(), G4PhysicalVolumeModel::GetCurrentPV(), G4Material::GetDensity(), G4PhysicalVolumeModel::GetDrawnPVPath(), G4VSolid::GetEntityType(), G4VSceneHandler::GetGraphicsSystem(), G4VPhysicalVolume::GetLogicalVolume(), G4LogicalVolume::GetMass(), G4VReadOutGeometry::GetName(), G4VSolid::GetName(), G4VSensitiveDetector::GetName(), G4VPhysicalVolume::GetName(), G4Material::GetName(), G4LogicalVolume::GetName(), G4LogicalVolume::GetNoDaughters(), G4VPhysicalVolume::GetParameterisation(), G4VPhysicalVolume::GetReplicationData(), G4VSensitiveDetector::GetROgeometry(), G4LogicalVolume::GetSensitiveDetector(), G4ASCIITree::GetVerbosity(), G4VPhysicalVolume::IsParameterised(), G4VPhysicalVolume::IsReplicated(), JustWarning, and width.

                                                                      {
   
   G4PhysicalVolumeModel* pPVModel =
     dynamic_cast<G4PhysicalVolumeModel*>(fpModel);
   if (!pPVModel) return;  // Not from a G4PhysicalVolumeModel.
 
   // This call comes from a G4PhysicalVolumeModel.  drawnPVPath is
   // the path of the current drawn (non-culled) volume in terms of
   // drawn (non-culled) ancesters.  Each node is identified by a
   // PVNodeID object, which is a physical volume and copy number.  It
   // is a vector of PVNodeIDs corresponding to the geometry hierarchy
   // actually selected, i.e., not culled.
   // The following typedef's already set in header file...
   //typedef G4PhysicalVolumeModel::G4PhysicalVolumeNodeID PVNodeID;
   //typedef std::vector<PVNodeID> PVPath;
   const PVPath& drawnPVPath = pPVModel->GetDrawnPVPath();
   //G4int currentDepth = pPVModel->GetCurrentDepth();
   G4VPhysicalVolume* pCurrentPV = pPVModel->GetCurrentPV();
   G4LogicalVolume* pCurrentLV = pPVModel->GetCurrentLV();
   G4Material* pCurrentMaterial = pPVModel->GetCurrentMaterial();
 
   G4ASCIITree* pSystem = (G4ASCIITree*)GetGraphicsSystem();
   G4int verbosity = pSystem->GetVerbosity();
   G4int detail = verbosity % 10;
 
   if (verbosity < 10 && pCurrentPV->IsReplicated()) {
     // See if this has been a replica found before with same mother LV...
     PVPath::const_reverse_iterator thisID = drawnPVPath.rbegin();
     PVPath::const_reverse_iterator motherID = ++drawnPVPath.rbegin();
     G4bool ignore = false;
     for (ReplicaSetIterator i = fReplicaSet.begin(); i != fReplicaSet.end();
      ++i) {
       if (i->back().GetPhysicalVolume()->GetLogicalVolume() ==
       thisID->GetPhysicalVolume()->GetLogicalVolume()) {
     // For each one previously found (if more than one, they must
     // have different mothers)...
     // To avoid compilation errors on VC++ .Net 7.1...
     // Previously:
     //   PVNodeID previousMotherID = ++(i->rbegin());
     // (Should that have been: PVNodeID::const_iterator previousMotherID?)
     // Replace
     //   previousMotherID == i->rend()
     // by
     //   i->size() <= 1
     // Replace
     //   previousMotherID != i->rend()
     // by
     //   i->size() > 1
     // Replace
     //   previousMotherID->
     // by
     //   (*i)[i->size() - 2].
     if (motherID == drawnPVPath.rend() &&
         i->size() <= 1)
       ignore = true;  // Both have no mother.
     if (motherID != drawnPVPath.rend() &&
         i->size() > 1 &&
         motherID->GetPhysicalVolume()->GetLogicalVolume() ==
         (*i)[i->size() - 2].GetPhysicalVolume()->GetLogicalVolume())
       ignore = true;  // Same mother LV...
       }
     }
     if (ignore) {
       pPVModel->CurtailDescent();
       return;
     }
   }
 
   const G4String& currentPVName = pCurrentPV->GetName();
   const G4int currentCopyNo = pCurrentPV->GetCopyNo();
 
   if (verbosity < 10 && 
       currentPVName == fLastPVName &&
       currentCopyNo != fLastCopyNo) {
     // For low verbosity, trap series of G4PVPlacements with the same name but
     // different copy number (replicas should have been taken out above)...
     // Check...
     if (pCurrentPV->IsReplicated()) {
       G4Exception("G4ASCIITreeSceneHandler::RequestPrimitives",
           "vistree0001",
           JustWarning,
           "Replica unexpected");
     }
     // Check mothers are identical...
     else if (pCurrentLV == (fpLastPV? fpLastPV->GetLogicalVolume(): 0)) {
       if (currentCopyNo != fLastCopyNo + 1) {
     // Non-sequential copy number...
     *fpOutFile << ',' << currentCopyNo;
     fLastNonSequentialCopyNo = currentCopyNo;
       }
       fLastCopyNo = currentCopyNo;
       pPVModel->CurtailDescent();
       return;
     }
   }
   fpLastPV = pCurrentPV;
 
   // High verbosity or a new G4VPhysicalVolume...
   // Output copy number, if any, from previous invocation...
   if (fLastCopyNo != fLastNonSequentialCopyNo) {
     if (fLastCopyNo == fLastNonSequentialCopyNo + 1) *fpOutFile << ',';
     else *fpOutFile << '-';
     *fpOutFile << fLastCopyNo;
   }
   // Output rest of line, if any, from previous invocation...
   if (!fRestOfLine.str().empty()) *fpOutFile << fRestOfLine.str();
   fRestOfLine.str("");
   fLastPVName = currentPVName;
   fLastCopyNo = currentCopyNo;
   fLastNonSequentialCopyNo = currentCopyNo;
   // Indent according to drawn path depth...
   for (size_t i = 0; i < drawnPVPath.size(); i++ ) *fpOutFile << "  ";
   // Start next line...
   *fpOutFile << "\"" << currentPVName
          << "\":" << currentCopyNo;
 
   if (pCurrentPV->IsReplicated()) {
     if (verbosity < 10) {
       // Add printing for replicas (when replicas are ignored)...
       EAxis axis;
       G4int nReplicas;
       G4double width;
       G4double offset;
       G4bool consuming;
       pCurrentPV->GetReplicationData(axis,nReplicas,width,offset,consuming);
       G4VPVParameterisation* pP = pCurrentPV->GetParameterisation();
       if (pP) {
     if (detail < 3) {
       fReplicaSet.insert(drawnPVPath);
       if (nReplicas > 2) fRestOfLine << '-';
       else fRestOfLine << ',';
       fRestOfLine << nReplicas - 1
               << " (" << nReplicas << " parametrised volumes)";
     }
       }
       else {
     fReplicaSet.insert(drawnPVPath);
     if (nReplicas > 2) fRestOfLine << '-';
     else fRestOfLine << ',';
     fRestOfLine << nReplicas - 1
             << " (" << nReplicas << " replicas)";
       }
     }
   } else {
     if (fLVSet.find(pCurrentLV) != fLVSet.end()) {
       if (verbosity <  10) {
     // Add printing for repeated LV (if it has daughters)...
     if (pCurrentLV->GetNoDaughters()) fRestOfLine << " (repeated LV)";
     // ...and curtail descent.
     pPVModel->CurtailDescent();
       }
     }
   }
 
   if (detail >= 1) {
     fRestOfLine << " / \""
         << pCurrentLV->GetName() << "\"";
     G4VSensitiveDetector* sd = pCurrentLV->GetSensitiveDetector();
     if (sd) {
       fRestOfLine << " (SD=\"" << sd->GetName() << "\"";
       G4VReadOutGeometry* roGeom = sd->GetROgeometry();
       if (roGeom) {
     fRestOfLine << ",RO=\"" << roGeom->GetName() << "\"";
       }
       fRestOfLine << ")";
     }
   }
 
   if (detail >= 2) {
     fRestOfLine << " / \""
            << solid.GetName()
            << "\"("
            << solid.GetEntityType() << ")";
   }
 
   if (detail >= 3) {
     fRestOfLine << ", "
         << G4BestUnit(((G4VSolid&)solid).GetCubicVolume(),"Volume")
         << ", ";
     if (pCurrentMaterial) {
       fRestOfLine
     << G4BestUnit(pCurrentMaterial->GetDensity(), "Volumic Mass")
     << " (" << pCurrentMaterial->GetName() << ")";
     } else {
       fRestOfLine << "(No material)";
     }
   }
 
   if (detail >= 5) {
     if (pCurrentMaterial) {
       G4Material* pMaterial = const_cast<G4Material*>(pCurrentMaterial);
       // ...and find daughter-subtracted mass...
       G4double daughter_subtracted_mass = pCurrentLV->GetMass
     (pCurrentPV->IsParameterised(),  // Force if parametrised.
      false,  // Do not propagate - calculate for this volume minus
      // volume of daughters.
      pMaterial);
       G4double daughter_subtracted_volume =
     daughter_subtracted_mass / pCurrentMaterial->GetDensity();
       fRestOfLine << ", "
           << G4BestUnit(daughter_subtracted_volume,"Volume")
           << ", "
           << G4BestUnit(daughter_subtracted_mass,"Mass");
     }
   }
 
   if (fLVSet.find(pCurrentLV) == fLVSet.end()) {
     fLVSet.insert(pCurrentLV);  // Record new logical volume.
   }
 
   fRestOfLine << std::endl;
 
   return;
 }

void G4ASCIITreeSceneHandler::WriteHeader ( std::ostream & os )

protected

Definition at line 92 of file G4ASCIITreeSceneHandler.cc.

References G4ASCIITreeMessenger::fVerbosityGuidance, G4VSceneHandler::GetGraphicsSystem(), and G4ASCIITree::GetVerbosity().

Referenced by BeginModeling().

 {
   const G4ASCIITree* pSystem = (G4ASCIITree*)GetGraphicsSystem();
   const G4int verbosity = pSystem->GetVerbosity();
   const G4int detail = verbosity % 10;
   os << "#  Set verbosity with \"/vis/ASCIITree/verbose <verbosity>\":";
   for (size_t i = 0;
        i < G4ASCIITreeMessenger::fVerbosityGuidance.size(); ++i) {
     os << "\n#  " << G4ASCIITreeMessenger::fVerbosityGuidance[i];
   }
   os << "\n#  Now printing with verbosity " << verbosity;
   os << "\n#  Format is: PV:n";
   if (detail >= 1) os << " / LV (SD,RO)";
   if (detail >= 2) os << " / Solid(type)";
   if (detail >= 3) os << ", volume, density";
   if (detail >= 5) os << ", daughter-subtracted volume and mass";
   os <<
     "\n#  Abbreviations: PV = Physical Volume,     LV = Logical Volume,"
     "\n#                 SD = Sensitive Detector,  RO = Read Out Geometry.";
 }