G4ASCIITreeSceneHandler Class Reference

#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 G4Plotter &)
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 G4Orb &)
virtual void	AddSolid (const G4Para &)
virtual void	AddSolid (const G4Sphere &)
virtual void	AddSolid (const G4Torus &)
virtual void	AddSolid (const G4Trap &)
virtual void	AddSolid (const G4Trd &)
virtual void	AddSolid (const G4Tubs &)
virtual void	AddSolid (const G4Ellipsoid &)
virtual void	AddSolid (const G4Polycone &)
virtual void	AddSolid (const G4Polyhedra &)
virtual void	AddSolid (const G4TessellatedSolid &)
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	AddCompound (const G4THitsMap< G4StatDouble > &)
virtual void	AddCompound (const G4Mesh &)
virtual void	BeginPrimitives (const G4Transform3D &objectTransformation=G4Transform3D())
virtual void	EndPrimitives ()
virtual void	BeginPrimitives2D (const G4Transform3D &objectTransformation=G4Transform3D())
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 G4Colour &	GetColor ()
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 *)
G4int	GetNumberOfCloudPoints (const G4VisAttributes *) const
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 ()
template<class T >
void	AddSolidT (const T &solid)
template<class T >
void	AddSolidWithAuxiliaryEdges (const T &solid)
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 G4DisplacedSolid *	CreateSectionSolid ()
virtual G4DisplacedSolid *	CreateCutawaySolid ()
void	LoadAtts (const G4Visible &, G4AttHolder *)
void	StandardSpecialMeshRendering (const G4Mesh &)
void	Draw3DRectMeshAsDots (const G4Mesh &)
void	Draw3DRectMeshAsSurfaces (const G4Mesh &)
void	DrawTetMeshAsDots (const G4Mesh &)
void	DrawTetMeshAsSurfaces (const G4Mesh &)
G4ThreeVector	GetPointInBox (const G4ThreeVector &pos, G4double halfX, G4double halfY, G4double halfZ) const
G4ThreeVector	GetPointInTet (const std::vector< G4ThreeVector > &vertices) const

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 47 of file G4ASCIITreeSceneHandler.hh.

Member Typedef Documentation

LVSetIterator

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

protected

Definition at line 72 of file G4ASCIITreeSceneHandler.hh.

PVNodeID

G4PhysicalVolumeModel::G4PhysicalVolumeNodeID G4ASCIITreeSceneHandler::PVNodeID

protected

Definition at line 73 of file G4ASCIITreeSceneHandler.hh.

PVPath

std::vector<PVNodeID> G4ASCIITreeSceneHandler::PVPath

protected

Definition at line 74 of file G4ASCIITreeSceneHandler.hh.

ReplicaSetIterator

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

protected

Definition at line 76 of file G4ASCIITreeSceneHandler.hh.

ReplicaSetReverseIterator

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

protected

Definition at line 77 of file G4ASCIITreeSceneHandler.hh.

Constructor & Destructor Documentation

G4ASCIITreeSceneHandler()

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::~G4ASCIITreeSceneHandler ( )

virtual

Definition at line 64 of file G4ASCIITreeSceneHandler.cc.

{}

Member Function Documentation

BeginModeling()

void G4ASCIITreeSceneHandler::BeginModeling ( )

virtual

Reimplemented from G4VTreeSceneHandler.

Definition at line 66 of file G4ASCIITreeSceneHandler.cc.

                                             {
 
  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;
  }
 
  static G4bool firstTime = true;
  if (firstTime) {
    firstTime = false;
    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;
  }
}

EndModeling()

void G4ASCIITreeSceneHandler::EndModeling ( )

virtual

Reimplemented from G4VTreeSceneHandler.

Definition at line 121 of file G4ASCIITreeSceneHandler.cc.

                                           {
  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) {
        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.
}

RequestPrimitives()

void G4ASCIITreeSceneHandler::RequestPrimitives ( const G4VSolid & solid )

protectedvirtual

Reimplemented from G4VSceneHandler.

Definition at line 192 of file G4ASCIITreeSceneHandler.cc.

                                                                     {
  
  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) ancestors.  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();
  const G4String& currentPVName = pCurrentPV->GetName();
  const G4int currentCopyNo = pCurrentPV->GetCopyNo();
  G4LogicalVolume* pCurrentLV = pPVModel->GetCurrentLV();
  G4Material* pCurrentMaterial = pPVModel->GetCurrentMaterial();
 
  G4ASCIITree* pSystem = (G4ASCIITree*)GetGraphicsSystem();
  G4int verbosity = pSystem->GetVerbosity();
  G4int detail = verbosity % 10;
 
  // If verbosity < 10 suppress unnecessary repeated printing.
  // Repeated simple replicas can always be suppressed.
  // Paramaterisations can only be suppressed if verbosity < 3, since their
  // size, density, etc., are in principle different.
  const G4bool isParameterised = pCurrentPV->GetParameterisation();
  const G4bool isSimpleReplica = pCurrentPV->IsReplicated() && !isParameterised;
  const G4bool isAmenableToSupression =
  (verbosity < 10 && isSimpleReplica) || (verbosity < 3 && isParameterised);
  if (isAmenableToSupression) {
    // See if this has been 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;
    }
  }
 
  // Now suppress printing for volumes with the same name but different
  // copy number - but not if they are parameterisations that have not been
  // taken out above (those that are "amenable to suppression" will have been
  // taken out).
  if (verbosity < 10 && !isParameterised &&
      currentPVName == fLastPVName &&
      currentCopyNo != fLastCopyNo) {
    // Check...
    if (isAmenableToSupression) {
      G4Exception("G4ASCIITreeSceneHandler::RequestPrimitives",
          "vistree0001",
          JustWarning,
          "Volume amenable to suppressed printing 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 or otherwise non-amenable volume...
  // 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;
  // Start next line...
  // Indent according to drawn path depth...
  for (size_t i = 0; i < drawnPVPath.size(); i++ ) *fpOutFile << "  ";
  *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 (detail >= 6) {
    std::vector<G4AttValue>* attValues = pPVModel->CreateCurrentAttValues();
    const std::map<G4String,G4AttDef>* attDefs = pPVModel->GetAttDefs();
    fRestOfLine << '\n' << G4AttCheck(attValues, attDefs);
    delete attValues;
  }
 
  if (detail >= 7) {
    G4Polyhedron* polyhedron = solid.GetPolyhedron();
    fRestOfLine << "\nLocal polyhedron coordinates:\n" << *polyhedron;
    const G4Transform3D& transform = pPVModel->GetCurrentTransform();
    polyhedron->Transform(transform);
    fRestOfLine << "\nGlobal polyhedron coordinates:\n" << *polyhedron;
  }
 
  if (fLVSet.find(pCurrentLV) == fLVSet.end()) {
    fLVSet.insert(pCurrentLV);  // Record new logical volume.
  }
 
  fRestOfLine << std::endl;
 
  return;
}

WriteHeader()

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

protected

Definition at line 98 of file G4ASCIITreeSceneHandler.cc.

{
  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";
  if (detail >= 6) os << ", physical volume dump";
  if (detail >= 7) os << ", polyhedron dump";
  os <<
    "\n#  Abbreviations: PV = Physical Volume,     LV = Logical Volume,"
    "\n#                 SD = Sensitive Detector,  RO = Read Out Geometry.";
}

Referenced by BeginModeling().

Member Data Documentation

fLastCopyNo

G4int G4ASCIITreeSceneHandler::fLastCopyNo

protected

Definition at line 68 of file G4ASCIITreeSceneHandler.hh.

Referenced by EndModeling(), and RequestPrimitives().

fLastNonSequentialCopyNo

G4int G4ASCIITreeSceneHandler::fLastNonSequentialCopyNo

protected

Definition at line 69 of file G4ASCIITreeSceneHandler.hh.

Referenced by EndModeling(), and RequestPrimitives().

fLastPVName

G4String G4ASCIITreeSceneHandler::fLastPVName

protected

Definition at line 67 of file G4ASCIITreeSceneHandler.hh.

Referenced by EndModeling(), and RequestPrimitives().

fLVSet

std::set<G4LogicalVolume*> G4ASCIITreeSceneHandler::fLVSet

protected

Definition at line 71 of file G4ASCIITreeSceneHandler.hh.

Referenced by EndModeling(), and RequestPrimitives().

fOutFile

std::ofstream G4ASCIITreeSceneHandler::fOutFile

protected

Definition at line 62 of file G4ASCIITreeSceneHandler.hh.

Referenced by BeginModeling(), and EndModeling().

fpLastPV

const G4VPhysicalVolume* G4ASCIITreeSceneHandler::fpLastPV

protected

Definition at line 66 of file G4ASCIITreeSceneHandler.hh.

Referenced by EndModeling(), and RequestPrimitives().

fpOutFile

std::ostream* G4ASCIITreeSceneHandler::fpOutFile

protected

Definition at line 61 of file G4ASCIITreeSceneHandler.hh.

Referenced by BeginModeling(), EndModeling(), and RequestPrimitives().

fReplicaSet

std::set<PVPath> G4ASCIITreeSceneHandler::fReplicaSet

protected

Definition at line 75 of file G4ASCIITreeSceneHandler.hh.

Referenced by EndModeling(), and RequestPrimitives().

fRestOfLine

std::ostringstream G4ASCIITreeSceneHandler::fRestOfLine

protected

Definition at line 63 of file G4ASCIITreeSceneHandler.hh.

Referenced by EndModeling(), and RequestPrimitives().

---

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

• G4ASCIITreeSceneHandler.hh
• G4ASCIITreeSceneHandler.cc