G4PhysicalVolumeModel Class Reference

#include <G4PhysicalVolumeModel.hh>

Inheritance diagram for G4PhysicalVolumeModel:

Data Structures
class	G4PhysicalVolumeModelTouchable
class	G4PhysicalVolumeNodeID
struct	TouchableProperties

Public Types
enum	{ UNLIMITED = -1 }
enum	ClippingMode { subtraction , intersection }

Public Member Functions
void	Abort () const
void	CalculateExtent ()
std::vector< G4AttValue > *	CreateCurrentAttValues () const
void	CurtailDescent () const
void	DescribeYourselfTo (G4VGraphicsScene &)
	G4PhysicalVolumeModel (G4VPhysicalVolume *=0, G4int requestedDepth=UNLIMITED, const G4Transform3D &modelTransformation=G4Transform3D(), const G4ModelingParameters *=0, G4bool useFullExtent=false, const std::vector< G4PhysicalVolumeNodeID > &baseFullPVPath=std::vector< G4PhysicalVolumeNodeID >())
const std::map< G4String, G4AttDef > *	GetAttDefs () const
const std::vector< G4PhysicalVolumeNodeID > &	GetBaseFullPVPath () const
const G4VSolid *	GetClippingSolid () const
G4int	GetCurrentDepth () const
G4String	GetCurrentDescription () const
G4LogicalVolume *	GetCurrentLV () const
G4Material *	GetCurrentMaterial () const
G4VPhysicalVolume *	GetCurrentPV () const
G4int	GetCurrentPVCopyNo () const
G4String	GetCurrentTag () const
const G4Transform3D &	GetCurrentTransform () const
const std::vector< G4PhysicalVolumeNodeID > &	GetDrawnPVPath () const
const G4VisExtent &	GetExtent () const
const std::vector< G4PhysicalVolumeNodeID > &	GetFullPVPath () const
const G4String &	GetGlobalDescription () const
const G4String &	GetGlobalTag () const
const G4ModelingParameters *	GetModelingParameters () const
G4int	GetRequestedDepth () const
G4VPhysicalVolume *	GetTopPhysicalVolume () const
const G4Transform3D &	GetTransformation () const
const G4String &	GetType () const
void	SetClippingMode (ClippingMode mode)
void	SetClippingSolid (G4VSolid *pClippingSolid)
void	SetExtent (const G4VisExtent &)
void	SetGlobalDescription (const G4String &)
void	SetGlobalTag (const G4String &)
void	SetModelingParameters (const G4ModelingParameters *)
void	SetRequestedDepth (G4int requestedDepth)
void	SetType (const G4String &)
G4bool	Validate (G4bool warn)
virtual	~G4PhysicalVolumeModel ()

Static Public Member Functions
static G4ModelingParameters::PVNameCopyNoPath	GetPVNameCopyNoPath (const std::vector< G4PhysicalVolumeNodeID > &)

Protected Member Functions
void	DescribeAndDescend (G4VPhysicalVolume *, G4int requestedDepth, G4LogicalVolume *, G4VSolid *, G4Material *, const G4Transform3D &, G4VGraphicsScene &)
virtual void	DescribeSolid (const G4Transform3D &theAT, G4VSolid *pSol, const G4VisAttributes *pVisAttribs, G4VGraphicsScene &sceneHandler)
void	VisitGeometryAndGetVisReps (G4VPhysicalVolume *, G4int requestedDepth, const G4Transform3D &, G4VGraphicsScene &)

Protected Attributes
G4bool	fAbort
std::vector< G4PhysicalVolumeNodeID >	fBaseFullPVPath
ClippingMode	fClippingMode
G4int	fCurrentDepth
G4int	fCurrentPVCopyNo
G4Transform3D	fCurrentTransform
G4bool	fCurtailDescent
std::vector< G4PhysicalVolumeNodeID >	fDrawnPVPath
G4VisExtent	fExtent
std::vector< G4PhysicalVolumeNodeID >	fFullPVPath
G4String	fGlobalDescription
G4String	fGlobalTag
G4VSolid *	fpClippingSolid
G4LogicalVolume *	fpCurrentLV
G4Material *	fpCurrentMaterial
G4VPhysicalVolume *	fpCurrentPV
const G4ModelingParameters *	fpMP
G4VPhysicalVolume *	fpTopPV
G4int	fRequestedDepth
G4int	fTopPVCopyNo
G4String	fTopPVName
G4Transform3D	fTransform
G4String	fType
G4bool	fUseFullExtent

Private Member Functions
	G4PhysicalVolumeModel (const G4PhysicalVolumeModel &)
G4PhysicalVolumeModel &	operator= (const G4PhysicalVolumeModel &)

Detailed Description

Definition at line 82 of file G4PhysicalVolumeModel.hh.

Member Enumeration Documentation

anonymous enum

anonymous enum

Enumerator
UNLIMITED

Definition at line 86 of file G4PhysicalVolumeModel.hh.

{UNLIMITED = -1};

ClippingMode

enum G4PhysicalVolumeModel::ClippingMode

Enumerator
subtraction
intersection

Definition at line 88 of file G4PhysicalVolumeModel.hh.

{subtraction, intersection};

Constructor & Destructor Documentation

G4PhysicalVolumeModel() [1/2]

G4PhysicalVolumeModel::G4PhysicalVolumeModel	(	G4VPhysicalVolume *	pVPV = 0,
		G4int	requestedDepth = UNLIMITED,
		const G4Transform3D &	modelTransformation = G4Transform3D(),
		const G4ModelingParameters *	pMP = 0,
		G4bool	useFullExtent = false,
		const std::vector< G4PhysicalVolumeNodeID > &	baseFullPVPath = std::vector<G4PhysicalVolumeNodeID>()
	)

Definition at line 63 of file G4PhysicalVolumeModel.cc.

: G4VModel           (pMP)
, fpTopPV            (pVPV)
, fTopPVCopyNo       (pVPV? pVPV->GetCopyNo(): 0)
, fRequestedDepth    (requestedDepth)
, fUseFullExtent     (useFullExtent)
, fTransform         (modelTransform)
, fCurrentDepth      (0)
, fpCurrentPV        (fpTopPV)
, fCurrentPVCopyNo   (fpTopPV? fpTopPV->GetCopyNo(): 0)
, fpCurrentLV        (fpTopPV? fpTopPV->GetLogicalVolume(): 0)
, fpCurrentMaterial  (fpCurrentLV? fpCurrentLV->GetMaterial(): 0)
, fCurrentTransform  (modelTransform)
, fBaseFullPVPath    (baseFullPVPath)
, fAbort             (false)
, fCurtailDescent    (false)
, fpClippingSolid    (0)
, fClippingMode      (subtraction)
{
  fType = "G4PhysicalVolumeModel";
 
  if (!fpTopPV) {
 
    // In some circumstances creating an "empty" G4PhysicalVolumeModel is
    // allowed, so I have supressed the G4Exception below.  If it proves to
    // be a problem we might have to re-instate it, but it is unlikley to
    // be used except by visualisation experts.  See, for example, /vis/list,
    // where it is used simply to get a list of G4AttDefs.
    //    G4Exception
    //    ("G4PhysicalVolumeModel::G4PhysicalVolumeModel",
    //     "modeling0010", FatalException, "Null G4PhysicalVolumeModel pointer.");
 
    fTopPVName = "NULL";
    fGlobalTag = "Empty";
    fGlobalDescription = "G4PhysicalVolumeModel " + fGlobalTag;
 
  } else {
 
    fTopPVName = fpTopPV -> GetName ();
    std::ostringstream oss;
    oss << fpTopPV->GetName() << ':' << fpTopPV->GetCopyNo()
    << " BasePath:" << fBaseFullPVPath;
    fGlobalTag = oss.str();
    fGlobalDescription = "G4PhysicalVolumeModel " + fGlobalTag;
    CalculateExtent ();
  }
}

References CalculateExtent(), fBaseFullPVPath, G4VModel::fGlobalDescription, G4VModel::fGlobalTag, fpTopPV, fTopPVName, G4VModel::fType, G4VPhysicalVolume::GetCopyNo(), and G4VPhysicalVolume::GetName().

~G4PhysicalVolumeModel()

G4PhysicalVolumeModel::~G4PhysicalVolumeModel ( )

virtual

Definition at line 117 of file G4PhysicalVolumeModel.cc.

{
  delete fpClippingSolid;
}

References fpClippingSolid.

G4PhysicalVolumeModel() [2/2]

G4PhysicalVolumeModel::G4PhysicalVolumeModel ( const G4PhysicalVolumeModel &  )

private

Member Function Documentation

Abort()

void G4PhysicalVolumeModel::Abort ( ) const

inline

Definition at line 251 of file G4PhysicalVolumeModel.hh.

{fAbort = true;}

References fAbort.

Referenced by G4TouchablePropertiesScene::ProcessVolume().

CalculateExtent()

void G4PhysicalVolumeModel::CalculateExtent

(

)

Definition at line 134 of file G4PhysicalVolumeModel.cc.

{
  // To handle paramaterisations, set copy number and compute dimensions
  // to get extent right
  G4VPVParameterisation* pP = fpTopPV -> GetParameterisation ();
  if (pP) {
    fpTopPV -> SetCopyNo (fTopPVCopyNo);
    G4VSolid* solid = pP -> ComputeSolid (fTopPVCopyNo, fpTopPV);
    solid -> ComputeDimensions (pP, fTopPVCopyNo, fpTopPV);
  }
  if (fUseFullExtent) {
    fExtent = fpTopPV -> GetLogicalVolume () -> GetSolid () -> GetExtent ();
  } else {
    // Calculate extent of *drawn* volumes, i.e., ignoring culled, e.g.,
    // invisible volumes, by traversing the whole geometry hierarchy below
    // this physical volume.
    G4BoundingExtentScene beScene(this);
    const G4int tempRequestedDepth = fRequestedDepth;
    const G4Transform3D tempTransform = fTransform;
    const G4ModelingParameters* tempMP = fpMP;
    fRequestedDepth = -1;  // Always search to all depths to define extent.
    fTransform = G4Transform3D();  // Extent is in local cooridinates
    G4ModelingParameters mParams
      (0,      // No default vis attributes needed.
       G4ModelingParameters::wf,  // wireframe (not relevant for this).
       true,   // Global culling.
       true,   // Cull invisible volumes.
       false,  // Density culling.
       0.,     // Density (not relevant if density culling false).
       true,   // Cull daughters of opaque mothers.
       24);    // No of sides (not relevant for this operation).
    fpMP = &mParams;
    DescribeYourselfTo (beScene);
    fExtent = beScene.GetBoundingExtent();
    fpMP = tempMP;
    fTransform = tempTransform;
    fRequestedDepth = tempRequestedDepth;
  }
  G4double radius = fExtent.GetExtentRadius();
  if (radius < 0.) {  // Nothing in the scene - revert to top extent
    fExtent = fpTopPV -> GetLogicalVolume () -> GetSolid () -> GetExtent ();
  }
  fExtent.Transform(fTransform);
}

References DescribeYourselfTo(), G4VModel::fExtent, G4VModel::fpMP, fpTopPV, fRequestedDepth, fTopPVCopyNo, fTransform, fUseFullExtent, G4BoundingExtentScene::GetBoundingExtent(), G4VModel::GetExtent(), G4VisExtent::GetExtentRadius(), G4VisExtent::Transform(), and G4ModelingParameters::wf.

Referenced by G4PhysicalVolumeModel(), and G4VVisCommandGeometrySet::Set().

CreateCurrentAttValues()

std::vector< G4AttValue > * G4PhysicalVolumeModel::CreateCurrentAttValues

(

)

const

Definition at line 984 of file G4PhysicalVolumeModel.cc.

{
  std::vector<G4AttValue>* values = new std::vector<G4AttValue>;
 
  if (!fpCurrentLV) {
     G4Exception
        ("G4PhysicalVolumeModel::CreateCurrentAttValues",
         "modeling0004",
         JustWarning,
         "Current logical volume not defined.");
     return values;
  }
 
  std::ostringstream oss; oss << fFullPVPath;
  values->push_back(G4AttValue("PVPath", oss.str(),""));
  oss.str(""); oss << fBaseFullPVPath;
  values->push_back(G4AttValue("BasePVPath", oss.str(),""));
  values->push_back(G4AttValue("LVol", fpCurrentLV->GetName(),""));
  G4VSolid* pSol = fpCurrentLV->GetSolid();
  values->push_back(G4AttValue("Solid", pSol->GetName(),""));
  values->push_back(G4AttValue("EType", pSol->GetEntityType(),""));
  oss.str(""); oss << '\n' << *pSol;
  values->push_back(G4AttValue("DmpSol", oss.str(),""));
  const G4RotationMatrix localRotation = fpCurrentPV->GetObjectRotationValue();
  const G4ThreeVector& localTranslation = fpCurrentPV->GetTranslation();
  oss.str(""); oss << '\n' << G4Transform3D(localRotation,localTranslation);
  values->push_back(G4AttValue("LocalTrans", oss.str(),""));
  oss.str(""); oss << '\n' << fCurrentTransform;
  values->push_back(G4AttValue("GlobalTrans", oss.str(),""));
  G4String matName = fpCurrentMaterial? fpCurrentMaterial->GetName(): G4String("No material");
  values->push_back(G4AttValue("Material", matName,""));
  G4double matDensity = fpCurrentMaterial? fpCurrentMaterial->GetDensity(): 0.;
  values->push_back(G4AttValue("Density", G4BestUnit(matDensity,"Volumic Mass"),""));
  G4State matState = fpCurrentMaterial? fpCurrentMaterial->GetState(): kStateUndefined;
  oss.str(""); oss << matState;
  values->push_back(G4AttValue("State", oss.str(),""));
  G4double matRadlen = fpCurrentMaterial? fpCurrentMaterial->GetRadlen(): 0.;
  values->push_back(G4AttValue("Radlen", G4BestUnit(matRadlen,"Length"),""));
  G4Region* region = fpCurrentLV->GetRegion();
  G4String regionName = region? region->GetName(): G4String("No region");
  values->push_back(G4AttValue("Region", regionName,""));
  oss.str(""); oss << fpCurrentLV->IsRootRegion();
  values->push_back(G4AttValue("RootRegion", oss.str(),""));
  return values;
}

References fBaseFullPVPath, fCurrentTransform, fFullPVPath, fpCurrentLV, fpCurrentMaterial, fpCurrentPV, G4BestUnit, G4Exception(), G4Material::GetDensity(), G4VSolid::GetEntityType(), G4LogicalVolume::GetName(), G4Region::GetName(), G4VSolid::GetName(), G4Material::GetName(), G4VPhysicalVolume::GetObjectRotationValue(), G4Material::GetRadlen(), G4LogicalVolume::GetRegion(), G4LogicalVolume::GetSolid(), G4Material::GetState(), G4VPhysicalVolume::GetTranslation(), G4LogicalVolume::IsRootRegion(), JustWarning, and kStateUndefined.

Referenced by G4VSceneHandler::LoadAtts(), G4ASCIITreeSceneHandler::RequestPrimitives(), and G4VisCommandsTouchable::SetNewValue().

CurtailDescent()

void G4PhysicalVolumeModel::CurtailDescent ( ) const

inline

Definition at line 254 of file G4PhysicalVolumeModel.hh.

{fCurtailDescent = true;}

References fCurtailDescent.

Referenced by G4PhysicalVolumesSearchScene::ProcessVolume(), G4BoundingExtentScene::ProcessVolume(), G4BoundingSphereScene::ProcessVolume(), and G4ASCIITreeSceneHandler::RequestPrimitives().

DescribeAndDescend()

void G4PhysicalVolumeModel::DescribeAndDescend ( G4VPhysicalVolume *  pVPV, G4int  requestedDepth, G4LogicalVolume *  pLV, G4VSolid *  pSol, G4Material *  pMaterial, const G4Transform3D &  theAT, G4VGraphicsScene &  sceneHandler  )

protected

Definition at line 381 of file G4PhysicalVolumeModel.cc.

{
  // Maintain useful data members...
  fpCurrentPV = pVPV;
  fCurrentPVCopyNo = pVPV->GetCopyNo();
  fpCurrentLV = pLV;
  fpCurrentMaterial = pMaterial;
 
  // Create a nodeID for use below - note the "drawn" flag is true
  G4int copyNo = fpCurrentPV->GetCopyNo();
  auto nodeID = G4PhysicalVolumeNodeID
  (fpCurrentPV,copyNo,fCurrentDepth,fCurrentTransform);
 
  // Update full path of physical volumes...
  fFullPVPath.push_back(nodeID);
 
  const G4RotationMatrix objectRotation = pVPV -> GetObjectRotationValue ();
  const G4ThreeVector&  translation     = pVPV -> GetTranslation ();
  G4Transform3D theLT (G4Transform3D (objectRotation, translation));
 
  // Compute the accumulated transformation...
  // Note that top volume's transformation relative to the world
  // coordinate system is specified in theAT == startingTransformation
  // = fTransform (see DescribeYourselfTo), so first time through the
  // volume's own transformation, which is only relative to its
  // mother, i.e., not relative to the world coordinate system, should
  // not be accumulated.
  G4Transform3D theNewAT (theAT);
  if (fCurrentDepth != 0) theNewAT = theAT * theLT;
  fCurrentTransform = theNewAT;
 
  const G4VisAttributes* pVisAttribs = pLV->GetVisAttributes();
  //  If the volume does not have any vis attributes, create it.
  G4VisAttributes* tempVisAtts = nullptr;
  if (!pVisAttribs) {
    if (fpMP->GetDefaultVisAttributes()) {
      tempVisAtts = new G4VisAttributes(*fpMP->GetDefaultVisAttributes());
    } else {
      tempVisAtts = new G4VisAttributes;
    }
    // The user may request /vis/viewer/set/colourByDensity.
    if (fpMP->GetCBDAlgorithmNumber() == 1) {
      // Algorithm 1: 3 parameters: Simple rainbow mapping.
      if (fpMP->GetCBDParameters().size() != 3) {
        G4Exception("G4PhysicalVolumeModelTouchable::DescribeAndDescend",
                    "modeling0014",
                    FatalErrorInArgument,
                    "Algorithm-parameter mismatch for Colour By Density");
      } else {
        const G4double d = pMaterial? pMaterial->GetDensity(): 0.;
        const G4double d0 = fpMP->GetCBDParameters()[0]; // Invisible d < d0.
        const G4double d1 = fpMP->GetCBDParameters()[1]; // Rainbow d0->d1->d2.
        const G4double d2 = fpMP->GetCBDParameters()[2]; // Blue d > d2.
        if (d < d0) { // Density < d0 is invisible.
          tempVisAtts->SetVisibility(false);
        } else { // Intermediate densities are on a spectrum.
          G4double red, green, blue;
          if (d < d1) {
            red = (d1-d)/(d1-d0); green = (d-d0)/(d1-d0); blue = 0.;
          } else if (d < d2) {
            red = 0.; green = (d2-d)/(d2-d1); blue = (d-d1)/(d2-d1);
          } else {  // Density >= d2 is blue.
            red = 0.; green = 0.; blue = 1.;
          }
          tempVisAtts->SetColour(G4Colour(red,green,blue));
        }
      }
    } else if (fpMP->GetCBDAlgorithmNumber() == 2) {
      // Algorithm 2
      // ...etc.
    }
    pVisAttribs = tempVisAtts;
  }
  // From here, can assume pVisAttribs is a valid pointer.  This is necessary
  // because PreAddSolid needs a vis attributes object.
 
  // Check if vis attributes are to be modified by a /vis/touchable/set/ command.
  const auto& vams = fpMP->GetVisAttributesModifiers();
  if (vams.size()) {
    // OK, we have some VAMs (Vis Attributes Modifiers).
    for (const auto& vam: vams) {
      const auto& vamPath = vam.GetPVNameCopyNoPath();
      if (vamPath.size() == fFullPVPath.size()) {
        // OK, we have a size match.
        // Check the volume name/copy number path.
        auto iVAMNameCopyNo = vamPath.begin();
        auto iPVNodeId = fFullPVPath.begin();
        for (; iVAMNameCopyNo != vamPath.end(); ++iVAMNameCopyNo, ++iPVNodeId) {
          if (!(
                iVAMNameCopyNo->GetName() ==
                iPVNodeId->GetPhysicalVolume()->GetName() &&
                iVAMNameCopyNo->GetCopyNo() ==
                iPVNodeId->GetPhysicalVolume()->GetCopyNo()
                )) {
            // This path element does NOT match.
            break;
          }
        }
        if (iVAMNameCopyNo == vamPath.end()) {
          // OK, the paths match (the above loop terminated normally).
          // Create a vis atts object for the modified vis atts.
          // It is static so that we may return a reliable pointer to it.
          static G4VisAttributes modifiedVisAtts;
          // Initialise it with the current vis atts and reset the pointer.
          modifiedVisAtts = *pVisAttribs;
          pVisAttribs = &modifiedVisAtts;
          const G4VisAttributes& transVisAtts = vam.GetVisAttributes();
          switch (vam.GetVisAttributesSignifier()) {
            case G4ModelingParameters::VASVisibility:
              modifiedVisAtts.SetVisibility(transVisAtts.IsVisible());
              break;
            case G4ModelingParameters::VASDaughtersInvisible:
              modifiedVisAtts.SetDaughtersInvisible
              (transVisAtts.IsDaughtersInvisible());
              break;
            case G4ModelingParameters::VASColour:
              modifiedVisAtts.SetColour(transVisAtts.GetColour());
              break;
            case G4ModelingParameters::VASLineStyle:
              modifiedVisAtts.SetLineStyle(transVisAtts.GetLineStyle());
              break;
            case G4ModelingParameters::VASLineWidth:
              modifiedVisAtts.SetLineWidth(transVisAtts.GetLineWidth());
              break;
            case G4ModelingParameters::VASForceWireframe:
              if (transVisAtts.IsForceDrawingStyle()) {
                if (transVisAtts.GetForcedDrawingStyle() ==
                    G4VisAttributes::wireframe) {
                  modifiedVisAtts.SetForceWireframe(true);
                }
              }
              break;
            case G4ModelingParameters::VASForceSolid:
              if (transVisAtts.IsForceDrawingStyle()) {
                if (transVisAtts.GetForcedDrawingStyle() ==
                    G4VisAttributes::solid) {
                  modifiedVisAtts.SetForceSolid(true);
                }
              }
              break;
            case G4ModelingParameters::VASForceCloud:
              if (transVisAtts.IsForceDrawingStyle()) {
                if (transVisAtts.GetForcedDrawingStyle() ==
                    G4VisAttributes::cloud) {
                  modifiedVisAtts.SetForceCloud(true);
                }
              }
              break;
            case G4ModelingParameters::VASForceNumberOfCloudPoints:
              modifiedVisAtts.SetForceNumberOfCloudPoints
              (transVisAtts.GetForcedNumberOfCloudPoints());
              break;
            case G4ModelingParameters::VASForceAuxEdgeVisible:
              if (transVisAtts.IsForceAuxEdgeVisible()) {
                modifiedVisAtts.SetForceAuxEdgeVisible
                (transVisAtts.IsForcedAuxEdgeVisible());
              }
              break;
            case G4ModelingParameters::VASForceLineSegmentsPerCircle:
              modifiedVisAtts.SetForceLineSegmentsPerCircle
              (transVisAtts.GetForcedLineSegmentsPerCircle());
              break;
          }
        }
      }
    }
  }
 
  // Check for special mesh rendering
  if (fpMP->IsSpecialMeshRendering()) {
    if (fpMP->GetSpecialMeshVolumes().empty()) {
      // No volumes specified - all are potentially possible
      goto create_mesh;
    } else {
      for (const auto& pvNameCopyNo: fpMP->GetSpecialMeshVolumes()) {
    if (pVPV->GetName() == pvNameCopyNo.GetName()) {
      // We have a name match
      if (pvNameCopyNo.GetCopyNo() < 0) {
        // Any copy number is OK
        goto create_mesh;
      } else {
        if (pVPV->GetCopyNo() == pvNameCopyNo.GetCopyNo()) {
          // We have a name and copy number match
          goto create_mesh;
        }
      }
    }
      }
      // We have fallen out of this loop without finding a match
      goto continue_processing;
    }
  create_mesh:
    // Create - or at least attempt to create - a mesh. If it cannot be created
    // out of this pVPV the type will be "invalid".
    G4Mesh mesh(pVPV,theNewAT);
    if (mesh.GetMeshType() != G4Mesh::invalid) {
      fFullPVPath.push_back(nodeID);
      fDrawnPVPath.push_back(nodeID);
      sceneHandler.AddCompound(mesh);
      fFullPVPath.pop_back();
      fDrawnPVPath.pop_back();
      delete tempVisAtts;  // Needs cleaning up (Coverity warning!!)
      return;
    }  // else continue processing
  }
continue_processing:
 
  // Make decision to draw...
  G4bool thisToBeDrawn = true;
 
  // There are various reasons why this volume
  // might not be drawn...
  G4bool culling = fpMP->IsCulling();
  G4bool cullingInvisible = fpMP->IsCullingInvisible();
  G4bool markedVisible
  = pVisAttribs->IsVisible() && pVisAttribs->GetColour().GetAlpha() > 0;
  G4bool cullingLowDensity = fpMP->IsDensityCulling();
  G4double density = pMaterial? pMaterial->GetDensity(): 0;
  G4double densityCut = fpMP -> GetVisibleDensity ();
 
  // 1) Global culling is on....
  if (culling) {
    // 2) Culling of invisible volumes is on...
    if (cullingInvisible) {
      // 3) ...and the volume is marked not visible...
      if (!markedVisible) thisToBeDrawn = false;
    }
    // 4) Or culling of low density volumes is on...
    if (cullingLowDensity) {
      // 5) ...and density is less than cut value...
      if (density < densityCut) thisToBeDrawn = false;
    }
  }
  // 6) The user has asked for all further traversing to be aborted...
  if (fAbort) thisToBeDrawn = false;
 
  // Set "drawn" flag (it was true by default) - thisToBeDrawn may be false
  nodeID.SetDrawn(thisToBeDrawn);
 
  if (thisToBeDrawn) {
 
    // Update path of drawn physical volumes...
    fDrawnPVPath.push_back(nodeID);
 
    if (fpMP->IsExplode() && fDrawnPVPath.size() == 1) {
      // For top-level drawn volumes, explode along radius...
      G4Transform3D centering = G4Translate3D(fpMP->GetExplodeCentre());
      G4Transform3D centred = centering.inverse() * theNewAT;
      G4Scale3D oldScale;
      G4Rotate3D oldRotation;
      G4Translate3D oldTranslation;
      centred.getDecomposition(oldScale, oldRotation, oldTranslation);
      G4double explodeFactor = fpMP->GetExplodeFactor();
      G4Translate3D newTranslation =
    G4Translate3D(explodeFactor * oldTranslation.dx(),
              explodeFactor * oldTranslation.dy(),
              explodeFactor * oldTranslation.dz());
      theNewAT = centering * newTranslation * oldRotation * oldScale;
    }
 
    volumeCount++;
    DescribeSolid (theNewAT, pSol, pVisAttribs, sceneHandler);
 
  }
 
  // Make decision to draw daughters, if any.  There are various
  // reasons why daughters might not be drawn...
 
  // First, reasons that do not depend on culling policy...
  G4int nDaughters = pLV->GetNoDaughters();
  G4bool daughtersToBeDrawn = true;
  // 1) There are no daughters...
  if (!nDaughters) daughtersToBeDrawn = false;
  // 2) We are at the limit if requested depth...
  else if (requestedDepth == 0) daughtersToBeDrawn = false;
  // 3) The user has asked for all further traversing to be aborted...
  else if (fAbort) daughtersToBeDrawn = false;
  // 4) The user has asked that the descent be curtailed...
  else if (fCurtailDescent) daughtersToBeDrawn = false;
 
  // Now, reasons that depend on culling policy...
  else {
    G4bool daughtersInvisible = pVisAttribs->IsDaughtersInvisible();
    // Culling of covered daughters request.  This is computed in
    // G4VSceneHandler::CreateModelingParameters() depending on view
    // parameters...
    G4bool cullingCovered = fpMP->IsCullingCovered();
    G4bool surfaceDrawing =
      fpMP->GetDrawingStyle() == G4ModelingParameters::hsr ||
      fpMP->GetDrawingStyle() == G4ModelingParameters::hlhsr;    
    if (pVisAttribs->IsForceDrawingStyle()) {
      switch (pVisAttribs->GetForcedDrawingStyle()) {
      default:
      case G4VisAttributes::wireframe: surfaceDrawing = false; break;
      case G4VisAttributes::solid: surfaceDrawing = true; break;
      }
    }
    G4bool opaque = pVisAttribs->GetColour().GetAlpha() >= 1.;
    // 5) Global culling is on....
    if (culling) {
      // 6) ..and culling of invisible volumes is on...
      if (cullingInvisible) {
    // 7) ...and the mother requests daughters invisible
    if (daughtersInvisible) daughtersToBeDrawn = false;
      }
      // 8) Or culling of covered daughters is requested...
      if (cullingCovered) {
    // 9) ...and surface drawing is operating...
    if (surfaceDrawing) {
      // 10) ...but only if mother is visible...
      if (thisToBeDrawn) {
        // 11) ...and opaque...
          if (opaque) daughtersToBeDrawn = false;
      }
    }
      }
    }
  }
 
  if (daughtersToBeDrawn) {
    for (G4int iDaughter = 0; iDaughter < nDaughters; iDaughter++) {
      // Store daughter pVPV in local variable ready for recursion...
      G4VPhysicalVolume* pDaughterVPV = pLV -> GetDaughter (iDaughter);
      // Descend the geometry structure recursively...
      fCurrentDepth++;
      VisitGeometryAndGetVisReps
    (pDaughterVPV, requestedDepth - 1, theNewAT, sceneHandler);
      fCurrentDepth--;
    }
  }
 
  // Clean up
  delete tempVisAtts;
 
  // Reset for normal descending of next volume at this level...
  fCurtailDescent = false;
 
  // Pop item from paths physical volumes...
  fFullPVPath.pop_back();
  if (thisToBeDrawn) {
    fDrawnPVPath.pop_back();
  }
}

References G4VGraphicsScene::AddCompound(), G4VisAttributes::cloud, d1, d2, DescribeSolid(), HepGeom::Transform3D::dx(), HepGeom::Transform3D::dy(), HepGeom::Transform3D::dz(), fAbort, FatalErrorInArgument, fCurrentDepth, fCurrentPVCopyNo, fCurrentTransform, fCurtailDescent, fDrawnPVPath, fFullPVPath, fpCurrentLV, fpCurrentMaterial, fpCurrentPV, G4VModel::fpMP, G4Exception(), G4Colour::GetAlpha(), G4ModelingParameters::GetCBDAlgorithmNumber(), G4ModelingParameters::GetCBDParameters(), G4VisAttributes::GetColour(), G4VPhysicalVolume::GetCopyNo(), HepGeom::Transform3D::getDecomposition(), G4ModelingParameters::GetDefaultVisAttributes(), G4Material::GetDensity(), G4ModelingParameters::GetDrawingStyle(), G4ModelingParameters::GetExplodeCentre(), G4ModelingParameters::GetExplodeFactor(), G4VisAttributes::GetForcedDrawingStyle(), G4VisAttributes::GetForcedLineSegmentsPerCircle(), G4VisAttributes::GetForcedNumberOfCloudPoints(), G4VisAttributes::GetLineStyle(), G4VisAttributes::GetLineWidth(), G4Mesh::GetMeshType(), G4VPhysicalVolume::GetName(), G4LogicalVolume::GetNoDaughters(), G4ModelingParameters::GetSpecialMeshVolumes(), G4LogicalVolume::GetVisAttributes(), G4ModelingParameters::GetVisAttributesModifiers(), G4ModelingParameters::hlhsr, G4ModelingParameters::hsr, G4Mesh::invalid, HepGeom::Transform3D::inverse(), G4ModelingParameters::IsCulling(), G4ModelingParameters::IsCullingCovered(), G4ModelingParameters::IsCullingInvisible(), G4VisAttributes::IsDaughtersInvisible(), G4ModelingParameters::IsDensityCulling(), G4ModelingParameters::IsExplode(), G4VisAttributes::IsForceAuxEdgeVisible(), G4VisAttributes::IsForcedAuxEdgeVisible(), G4VisAttributes::IsForceDrawingStyle(), G4ModelingParameters::IsSpecialMeshRendering(), G4VisAttributes::IsVisible(), G4VisAttributes::SetColour(), G4VisAttributes::SetDaughtersInvisible(), G4VisAttributes::SetForceAuxEdgeVisible(), G4VisAttributes::SetForceCloud(), G4VisAttributes::SetForceLineSegmentsPerCircle(), G4VisAttributes::SetForceNumberOfCloudPoints(), G4VisAttributes::SetForceSolid(), G4VisAttributes::SetForceWireframe(), G4VisAttributes::SetLineStyle(), G4VisAttributes::SetLineWidth(), G4VisAttributes::SetVisibility(), G4VisAttributes::solid, G4ModelingParameters::VASColour, G4ModelingParameters::VASDaughtersInvisible, G4ModelingParameters::VASForceAuxEdgeVisible, G4ModelingParameters::VASForceCloud, G4ModelingParameters::VASForceLineSegmentsPerCircle, G4ModelingParameters::VASForceNumberOfCloudPoints, G4ModelingParameters::VASForceSolid, G4ModelingParameters::VASForceWireframe, G4ModelingParameters::VASLineStyle, G4ModelingParameters::VASLineWidth, G4ModelingParameters::VASVisibility, VisitGeometryAndGetVisReps(), anonymous_namespace{G4PhysicalVolumeModel.cc}::volumeCount, and G4VisAttributes::wireframe.

Referenced by VisitGeometryAndGetVisReps().

DescribeSolid()

void G4PhysicalVolumeModel::DescribeSolid ( const G4Transform3D &  theAT, G4VSolid *  pSol, const G4VisAttributes *  pVisAttribs, G4VGraphicsScene &  sceneHandler  )

protectedvirtual

Reimplemented in G4LogicalVolumeModel.

Definition at line 732 of file G4PhysicalVolumeModel.cc.

{
  G4DisplacedSolid* pSectionSolid = fpMP->GetSectionSolid();
  G4DisplacedSolid* pCutawaySolid = fpMP->GetCutawaySolid();
 
  if (!fpClippingSolid && !pSectionSolid && !pCutawaySolid) {
 
    sceneHandler.PreAddSolid (theAT, *pVisAttribs);
    pSol -> DescribeYourselfTo (sceneHandler);  // Standard treatment.
    sceneHandler.PostAddSolid ();
 
  } else {
 
    // Clipping, etc., performed by Boolean operations.
 
    // First, get polyhedron for current solid...
    if (pVisAttribs->IsForceLineSegmentsPerCircle())
      G4Polyhedron::SetNumberOfRotationSteps
    (pVisAttribs->GetForcedLineSegmentsPerCircle());
    else
      G4Polyhedron::SetNumberOfRotationSteps(fpMP->GetNoOfSides());
    const G4Polyhedron* pOriginalPolyhedron = pSol->GetPolyhedron();
    G4Polyhedron::ResetNumberOfRotationSteps();
 
    if (!pOriginalPolyhedron) {
 
      if (fpMP->IsWarning())
    G4cout <<
      "WARNING: G4PhysicalVolumeModel::DescribeSolid: solid\n  \""
           << pSol->GetName() <<
      "\" has no polyhedron.  Cannot by clipped."
           << G4endl;
      pSol -> DescribeYourselfTo (sceneHandler);  // Standard treatment.
 
    } else {
 
      G4VSolid* pResultantSolid = 0;
 
      if (fpClippingSolid) {
    switch (fClippingMode) {
    default:
    case subtraction:
      pResultantSolid = new G4SubtractionSolid
        ("subtracted_clipped_solid", pSol, fpClippingSolid, theAT.inverse());
      break;
    case intersection:
      pResultantSolid = new G4IntersectionSolid
        ("intersected_clipped_solid", pSol, fpClippingSolid, theAT.inverse());
      break;
    }
      }
 
      if (pSectionSolid) {
    pResultantSolid = new G4IntersectionSolid
      ("sectioned_solid", pSol, pSectionSolid, theAT.inverse());
      }
 
      if (pCutawaySolid) {
        // Follow above...
    pResultantSolid = new G4SubtractionSolid
      ("cutaway_solid", pSol, pCutawaySolid, theAT.inverse());
      }
 
      G4Polyhedron* pResultantPolyhedron = pResultantSolid->GetPolyhedron();
      if (!pResultantPolyhedron) {
        if (fpMP->IsWarning())
          G4cout <<
          "WARNING: G4PhysicalVolumeModel::DescribeSolid: resultant polyhedron for"
          "\n  solid \"" << pSol->GetName() <<
          "\" not defined due to error during Boolean processing."
          << G4endl;
      } else {
        // It seems that if the sectioning solid does not intersect the
        // original solid the Boolean Processor returns the original
        // polyhedron, or a copy thereof. We do not want it.
        // Check the number of facets, etc. If same, ignore.
        // What we need from the Boolean Processor is a null pointer or a
        // null polyhedron. It seems to return the original or a copy of it.
        if (pResultantPolyhedron->GetNoFacets() == pOriginalPolyhedron->GetNoFacets())
          // This works in most cases but I still get a box in test202 with
          // /vis/viewer/set/sectionPlane on 0 0 0 m 0.1 0.1 1
        {
          pResultantPolyhedron = nullptr;
        }
      }
 
      if (pResultantPolyhedron) {
        // Finally, draw polyhedron...
        sceneHandler.BeginPrimitives(theAT);
    pResultantPolyhedron->SetVisAttributes(pVisAttribs);
        sceneHandler.AddPrimitive(*pResultantPolyhedron);
        sceneHandler.EndPrimitives();
      }
 
      delete pResultantSolid;
    }
  }
}

References G4VGraphicsScene::AddPrimitive(), G4VGraphicsScene::BeginPrimitives(), DescribeYourselfTo(), G4VGraphicsScene::EndPrimitives(), fClippingMode, fpClippingSolid, G4VModel::fpMP, G4cout, G4endl, G4ModelingParameters::GetCutawaySolid(), G4VisAttributes::GetForcedLineSegmentsPerCircle(), G4VSolid::GetName(), HepPolyhedron::GetNoFacets(), G4ModelingParameters::GetNoOfSides(), G4VSolid::GetPolyhedron(), G4ModelingParameters::GetSectionSolid(), intersection, HepGeom::Transform3D::inverse(), G4VisAttributes::IsForceLineSegmentsPerCircle(), G4ModelingParameters::IsWarning(), G4VGraphicsScene::PostAddSolid(), G4VGraphicsScene::PreAddSolid(), HepPolyhedron::ResetNumberOfRotationSteps(), HepPolyhedron::SetNumberOfRotationSteps(), G4Visible::SetVisAttributes(), and subtraction.

Referenced by DescribeAndDescend().

DescribeYourselfTo()

void G4PhysicalVolumeModel::DescribeYourselfTo ( G4VGraphicsScene &  sceneHandler )

virtual

Implements G4VModel.

Definition at line 179 of file G4PhysicalVolumeModel.cc.

{
  if (!fpTopPV) G4Exception
    ("G4PhysicalVolumeModel::DescribeYourselfTo",
     "modeling0012", FatalException, "No model.");
 
  if (!fpMP) G4Exception
    ("G4PhysicalVolumeModel::DescribeYourselfTo",
     "modeling0003", FatalException, "No modeling parameters.");
 
  G4Transform3D startingTransformation = fTransform;
 
  volumeCount = 0;
 
  VisitGeometryAndGetVisReps
    (fpTopPV,
     fRequestedDepth,
     startingTransformation,
     sceneHandler);
 
//  G4cout
//  << "G4PhysicalVolumeModel::DescribeYourselfTo: volume count: "
//  << volumeCount
//  << G4endl;
 
  // Reset or clear data...
  fCurrentDepth     = 0;
  fpCurrentPV       = fpTopPV;
  fCurrentPVCopyNo  = fpTopPV->GetCopyNo();
  fpCurrentLV       = fpTopPV->GetLogicalVolume();
  fpCurrentMaterial = fpCurrentLV? fpCurrentLV->GetMaterial(): 0;
  fFullPVPath       = fBaseFullPVPath;
  fDrawnPVPath.clear();
  fAbort            = false;
  fCurtailDescent   = false;
}

References fAbort, FatalException, fBaseFullPVPath, fCurrentDepth, fCurrentPVCopyNo, fCurtailDescent, fDrawnPVPath, fFullPVPath, fpCurrentLV, fpCurrentMaterial, fpCurrentPV, G4VModel::fpMP, fpTopPV, fRequestedDepth, fTransform, G4Exception(), G4VPhysicalVolume::GetCopyNo(), G4VPhysicalVolume::GetLogicalVolume(), G4LogicalVolume::GetMaterial(), VisitGeometryAndGetVisReps(), and anonymous_namespace{G4PhysicalVolumeModel.cc}::volumeCount.

Referenced by G4OpenGLSceneHandler::AddCompound(), G4Qt3DSceneHandler::AddCompound(), G4VtkSceneHandler::AddCompound(), CalculateExtent(), DescribeSolid(), G4LogicalVolumeModel::DescribeYourselfTo(), G4ASCIITreeSceneHandler::EndModeling(), G4TouchableUtils::FindTouchableProperties(), G4VisCommandSceneAddLocalAxes::SetNewValue(), G4VisCommandSceneAddVolume::SetNewValue(), G4VisCommandSetTouchable::SetNewValue(), G4VisCommandSetVolumeForField::SetNewValue(), G4VisCommandsTouchable::SetNewValue(), and G4VisCommandViewerCentreOn::SetNewValue().

GetAttDefs()

const std::map< G4String, G4AttDef > * G4PhysicalVolumeModel::GetAttDefs

(

)

const

Definition at line 907 of file G4PhysicalVolumeModel.cc.

{
    G4bool isNew;
    std::map<G4String,G4AttDef>* store
      = G4AttDefStore::GetInstance("G4PhysicalVolumeModel", isNew);
    if (isNew) {
      (*store)["PVPath"] =
      G4AttDef("PVPath","Physical Volume Path","Physics","","G4String");
      (*store)["BasePVPath"] =
      G4AttDef("BasePVPath","Base Physical Volume Path","Physics","","G4String");
      (*store)["LVol"] =
    G4AttDef("LVol","Logical Volume","Physics","","G4String");
      (*store)["Solid"] =
    G4AttDef("Solid","Solid Name","Physics","","G4String");
      (*store)["EType"] =
    G4AttDef("EType","Entity Type","Physics","","G4String");
      (*store)["DmpSol"] =
    G4AttDef("DmpSol","Dump of Solid properties","Physics","","G4String");
      (*store)["LocalTrans"] =
    G4AttDef("LocalTrans","Local transformation of volume","Physics","","G4String");
      (*store)["GlobalTrans"] =
    G4AttDef("GlobalTrans","Global transformation of volume","Physics","","G4String");
      (*store)["Material"] =
    G4AttDef("Material","Material Name","Physics","","G4String");
      (*store)["Density"] =
    G4AttDef("Density","Material Density","Physics","G4BestUnit","G4double");
      (*store)["State"] =
    G4AttDef("State","Material State (enum undefined,solid,liquid,gas)","Physics","","G4String");
      (*store)["Radlen"] =
    G4AttDef("Radlen","Material Radiation Length","Physics","G4BestUnit","G4double");
      (*store)["Region"] =
    G4AttDef("Region","Cuts Region","Physics","","G4String");
      (*store)["RootRegion"] =
    G4AttDef("RootRegion","Root Region (0/1 = false/true)","Physics","","G4bool");
    }
  return store;
}

References G4AttDefStore::GetInstance().

Referenced by G4VSceneHandler::LoadAtts(), G4ASCIITreeSceneHandler::RequestPrimitives(), G4VisCommandList::SetNewValue(), and G4VisCommandsTouchable::SetNewValue().

GetBaseFullPVPath()

const std::vector< G4PhysicalVolumeNodeID > & G4PhysicalVolumeModel::GetBaseFullPVPath ( ) const

inline

Definition at line 198 of file G4PhysicalVolumeModel.hh.

  {return fBaseFullPVPath;}

References fBaseFullPVPath.

GetClippingSolid()

const G4VSolid * G4PhysicalVolumeModel::GetClippingSolid ( ) const

inline

Definition at line 174 of file G4PhysicalVolumeModel.hh.

  {return fpClippingSolid;}

References fpClippingSolid.

GetCurrentDepth()

G4int G4PhysicalVolumeModel::GetCurrentDepth ( ) const

inline

Definition at line 177 of file G4PhysicalVolumeModel.hh.

{return fCurrentDepth;}

References fCurrentDepth.

Referenced by G4HepRepFileSceneHandler::AddHepRepInstance(), G4GMocrenFileSceneHandler::AddSolid(), G4VtkSceneHandler::AddSolid(), G4PhysicalVolumeMassScene::ProcessVolume(), G4PhysicalVolumeSearchScene::ProcessVolume(), and G4PhysicalVolumesSearchScene::ProcessVolume().

GetCurrentDescription()

G4String G4PhysicalVolumeModel::GetCurrentDescription ( ) const

virtual

Reimplemented from G4VModel.

Definition at line 229 of file G4PhysicalVolumeModel.cc.

{
  return "G4PhysicalVolumeModel " + GetCurrentTag ();
}

References GetCurrentTag().

GetCurrentLV()

G4LogicalVolume * G4PhysicalVolumeModel::GetCurrentLV ( ) const

inline

Definition at line 189 of file G4PhysicalVolumeModel.hh.

{return fpCurrentLV;}

References fpCurrentLV.

Referenced by G4GMocrenFileSceneHandler::AddDetector(), G4HepRepFileSceneHandler::AddHepRepInstance(), G4GMocrenFileSceneHandler::AddPrimitive(), G4OpenInventorSceneHandler::AddPrimitive(), G4OpenInventorSceneHandler::GeneratePrerequisites(), and G4ASCIITreeSceneHandler::RequestPrimitives().

GetCurrentMaterial()

G4Material * G4PhysicalVolumeModel::GetCurrentMaterial ( ) const

inline

Definition at line 192 of file G4PhysicalVolumeModel.hh.

{return fpCurrentMaterial;}

References fpCurrentMaterial.

Referenced by G4HepRepFileSceneHandler::AddHepRepInstance(), G4GMocrenFileSceneHandler::AddSolid(), G4VtkSceneHandler::AddSolid(), G4PhysicalVolumeMassScene::ProcessVolume(), and G4ASCIITreeSceneHandler::RequestPrimitives().

GetCurrentPV()

G4VPhysicalVolume * G4PhysicalVolumeModel::GetCurrentPV ( ) const

inline

Definition at line 183 of file G4PhysicalVolumeModel.hh.

{return fpCurrentPV;}

References fpCurrentPV.

Referenced by G4HepRepFileSceneHandler::AddHepRepInstance(), G4GMocrenFileSceneHandler::AddPrimitive(), G4OpenGLStoredSceneHandler::AddPrimitivePreambleInternal(), G4GMocrenFileSceneHandler::AddSolid(), G4VtkSceneHandler::AddSolid(), G4OpenInventorSceneHandler::GeneratePrerequisites(), G4PhysicalVolumeMassScene::ProcessVolume(), G4PhysicalVolumeSearchScene::ProcessVolume(), G4PhysicalVolumesSearchScene::ProcessVolume(), G4TouchablePropertiesScene::ProcessVolume(), and G4ASCIITreeSceneHandler::RequestPrimitives().

GetCurrentPVCopyNo()

G4int G4PhysicalVolumeModel::GetCurrentPVCopyNo ( ) const

inline

Definition at line 186 of file G4PhysicalVolumeModel.hh.

{return fCurrentPVCopyNo;}

References fCurrentPVCopyNo.

Referenced by G4PhysicalVolumesSearchScene::ProcessVolume(), and G4TouchablePropertiesScene::ProcessVolume().

GetCurrentTag()

G4String G4PhysicalVolumeModel::GetCurrentTag ( ) const

virtual

Reimplemented from G4VModel.

Definition at line 217 of file G4PhysicalVolumeModel.cc.

{
  if (fpCurrentPV) {
    std::ostringstream o;
    o << fpCurrentPV -> GetCopyNo ();
    return fpCurrentPV -> GetName () + ":" + o.str();
  }
  else {
    return "WARNING: NO CURRENT VOLUME - global tag is " + fGlobalTag;
  }
}

References G4VModel::fGlobalTag, and fpCurrentPV.

Referenced by GetCurrentDescription().

GetCurrentTransform()

const G4Transform3D & G4PhysicalVolumeModel::GetCurrentTransform ( ) const

inline

Definition at line 195 of file G4PhysicalVolumeModel.hh.

{return fCurrentTransform;}

References fCurrentTransform.

Referenced by G4TouchablePropertiesScene::ProcessVolume(), G4ASCIITreeSceneHandler::RequestPrimitives(), and G4VisCommandsTouchable::SetNewValue().

GetDrawnPVPath()

const std::vector< G4PhysicalVolumeNodeID > & G4PhysicalVolumeModel::GetDrawnPVPath ( ) const

inline

Definition at line 212 of file G4PhysicalVolumeModel.hh.

  {return fDrawnPVPath;}

References fDrawnPVPath.

Referenced by G4HepRepFileSceneHandler::AddHepRepInstance(), G4GMocrenFileSceneHandler::AddSolid(), G4OpenInventorSceneHandler::GeneratePrerequisites(), G4VTreeSceneHandler::PreAddSolid(), and G4ASCIITreeSceneHandler::RequestPrimitives().

GetExtent()

const G4VisExtent & G4VModel::GetExtent ( ) const

inherited

Referenced by CalculateExtent(), and G4VisCommandSceneAddLogicalVolume::SetNewValue().

GetFullPVPath()

const std::vector< G4PhysicalVolumeNodeID > & G4PhysicalVolumeModel::GetFullPVPath ( ) const

inline

Definition at line 205 of file G4PhysicalVolumeModel.hh.

  {return fFullPVPath;}

References fFullPVPath.

Referenced by G4OpenGLQtViewer::addPVSceneTreeElement(), G4RayTracerSceneHandler::BuildVisAttsMap(), G4Qt3DSceneHandler::CreateNewNode(), G4OpenGLQtViewer::parseAndInsertInSceneTree(), G4PhysicalVolumeSearchScene::ProcessVolume(), G4PhysicalVolumesSearchScene::ProcessVolume(), G4TouchablePropertiesScene::ProcessVolume(), and G4VSceneHandler::RequestPrimitives().

GetGlobalDescription()

const G4String & G4VModel::GetGlobalDescription ( ) const

inherited

Referenced by G4Scene::AddRunDurationModel(), and anonymous_namespace{G4Scene.cc}::PrintInvalidModel().

GetGlobalTag()

const G4String & G4VModel::GetGlobalTag ( ) const

inherited

Referenced by G4Qt3DSceneHandler::CreateNewNode().

GetModelingParameters()

const G4ModelingParameters * G4VModel::GetModelingParameters ( ) const

inherited

Referenced by G4ASCIITreeSceneHandler::EndModeling(), and G4OpenGLSceneHandler::ScaledFlush().

GetPVNameCopyNoPath()

G4ModelingParameters::PVNameCopyNoPath G4PhysicalVolumeModel::GetPVNameCopyNoPath ( const std::vector< G4PhysicalVolumeNodeID > &  path )

static

Definition at line 122 of file G4PhysicalVolumeModel.cc.

{
  G4ModelingParameters::PVNameCopyNoPath PVNameCopyNoPath;
  for (const auto& node: path) {
    PVNameCopyNoPath.push_back
    (G4ModelingParameters::PVNameCopyNo
     (node.GetPhysicalVolume()->GetName(),node.GetCopyNo()));
  }
  return PVNameCopyNoPath;
}

Referenced by G4VViewer::TouchableSetColour(), and G4VViewer::TouchableSetVisibility().

GetRequestedDepth()

G4int G4PhysicalVolumeModel::GetRequestedDepth ( ) const

inline

Definition at line 172 of file G4PhysicalVolumeModel.hh.

{return fRequestedDepth;}

References fRequestedDepth.

Referenced by G4ASCIITreeSceneHandler::EndModeling().

GetTopPhysicalVolume()

G4VPhysicalVolume * G4PhysicalVolumeModel::GetTopPhysicalVolume ( ) const

inline

Definition at line 170 of file G4PhysicalVolumeModel.hh.

{return fpTopPV;}

References fpTopPV.

Referenced by G4GMocrenFileSceneHandler::AddSolid(), G4VtkSceneHandler::AddSolid(), G4ASCIITreeSceneHandler::EndModeling(), and G4PhysicalVolumesSearchScene::ProcessVolume().

GetTransformation()

const G4Transform3D & G4PhysicalVolumeModel::GetTransformation ( ) const

inline

Definition at line 180 of file G4PhysicalVolumeModel.hh.

{return fTransform;}

References fTransform.

Referenced by G4OpenGLQtViewer::parseAndInsertInSceneTree().

GetType()

const G4String & G4VModel::GetType ( ) const

inherited

Referenced by G4OpenGLStoredQtSceneHandler::ExtraPOProcessing().

operator=()

G4PhysicalVolumeModel & G4PhysicalVolumeModel::operator= ( const G4PhysicalVolumeModel &  )

private

SetClippingMode()

void G4PhysicalVolumeModel::SetClippingMode ( ClippingMode  mode )

inline

Definition at line 244 of file G4PhysicalVolumeModel.hh.

                                           {
    fClippingMode = mode;
  }

References fClippingMode.

Referenced by G4VisCommandSceneAddVolume::SetNewValue().

SetClippingSolid()

void G4PhysicalVolumeModel::SetClippingSolid ( G4VSolid *  pClippingSolid )

inline

Definition at line 240 of file G4PhysicalVolumeModel.hh.

                                                   {
    fpClippingSolid = pClippingSolid;
  }

References fpClippingSolid.

Referenced by G4VisCommandSceneAddVolume::SetNewValue().

SetExtent()

void G4VModel::SetExtent ( const G4VisExtent &  )

inherited

Referenced by G4VisCommandSceneAddUserAction::AddVisAction(), G4VisCommandSceneAddExtent::SetNewValue(), G4VisCommandSceneAddLogo::SetNewValue(), and G4VisCommandSceneAddScale::SetNewValue().

SetGlobalDescription()

void G4VModel::SetGlobalDescription ( const G4String &  )

inherited

Referenced by G4VisCommandSceneAddUserAction::AddVisAction(), G4VisCommandSceneAddArrow2D::SetNewValue(), G4VisCommandSceneAddDate::SetNewValue(), G4VisCommandSceneAddEventID::SetNewValue(), G4VisCommandSceneAddExtent::SetNewValue(), G4VisCommandSceneAddFrame::SetNewValue(), G4VisCommandSceneAddLine::SetNewValue(), G4VisCommandSceneAddLine2D::SetNewValue(), G4VisCommandSceneAddLogo::SetNewValue(), G4VisCommandSceneAddLogo2D::SetNewValue(), G4VisCommandSceneAddScale::SetNewValue(), and G4VisCommandSceneAddText2D::SetNewValue().

SetGlobalTag()

void G4VModel::SetGlobalTag ( const G4String &  )

inherited

Referenced by G4VisCommandSceneAddUserAction::AddVisAction(), G4VisCommandSceneAddArrow2D::SetNewValue(), G4VisCommandSceneAddDate::SetNewValue(), G4VisCommandSceneAddEventID::SetNewValue(), G4VisCommandSceneAddExtent::SetNewValue(), G4VisCommandSceneAddFrame::SetNewValue(), G4VisCommandSceneAddLine::SetNewValue(), G4VisCommandSceneAddLine2D::SetNewValue(), G4VisCommandSceneAddLogo::SetNewValue(), G4VisCommandSceneAddLogo2D::SetNewValue(), G4VisCommandSceneAddScale::SetNewValue(), G4VisCommandSceneAddText2D::SetNewValue(), and G4VisCommandsTouchable::SetNewValue().

SetModelingParameters()

void G4VModel::SetModelingParameters ( const G4ModelingParameters *  )

inherited

Referenced by G4LogicalVolumeModel::DescribeYourselfTo(), G4ASCIITreeSceneHandler::EndModeling(), G4TouchableUtils::FindTouchableProperties(), G4VSceneHandler::ProcessScene(), G4VisCommandSetTouchable::SetNewValue(), G4VisCommandSetVolumeForField::SetNewValue(), G4VisCommandsTouchable::SetNewValue(), and G4VisCommandViewerCentreOn::SetNewValue().

SetRequestedDepth()

void G4PhysicalVolumeModel::SetRequestedDepth ( G4int  requestedDepth )

inline

Definition at line 236 of file G4PhysicalVolumeModel.hh.

                                                {
    fRequestedDepth = requestedDepth;
  }

References fRequestedDepth.

SetType()

void G4VModel::SetType ( const G4String &  )

inherited

Referenced by G4VisCommandSceneAddUserAction::AddVisAction(), G4VisCommandSceneAddArrow2D::SetNewValue(), G4VisCommandSceneAddDate::SetNewValue(), G4VisCommandSceneAddEventID::SetNewValue(), G4VisCommandSceneAddExtent::SetNewValue(), G4VisCommandSceneAddFrame::SetNewValue(), G4VisCommandSceneAddLine::SetNewValue(), G4VisCommandSceneAddLine2D::SetNewValue(), G4VisCommandSceneAddLogo::SetNewValue(), G4VisCommandSceneAddLogo2D::SetNewValue(), G4VisCommandSceneAddScale::SetNewValue(), and G4VisCommandSceneAddText2D::SetNewValue().

Validate()

G4bool G4PhysicalVolumeModel::Validate ( G4bool  warn )

virtual

Reimplemented from G4VModel.

Definition at line 835 of file G4PhysicalVolumeModel.cc.

{
// Not easy to see how to validate this sort of model. Previously there was
// a check that a volume of the same name (fTopPVName) existed somewhere in
// the geometry tree but under some circumstances this consumed lots of CPU
// time. Instead, let us simply check that the volume (fpTopPV) exists in the
// physical volume store.
 
  const auto& pvStore = G4PhysicalVolumeStore::GetInstance();
  auto iterator = find(pvStore->begin(),pvStore->end(),fpTopPV);
  if (iterator == pvStore->end()) {
    if (warn) {
      G4ExceptionDescription ed;
      ed << "Attempt to validate a volume that is no longer in the physical volume store.";
      G4Exception("G4PhysicalVolumeModel::Validate", "modeling0015", JustWarning, ed);
    }
    return false;
  } else {
    return true;
  }
 
  // Previous algorithm
//  G4TransportationManager* transportationManager =
//    G4TransportationManager::GetTransportationManager ();
//  size_t nWorlds = transportationManager->GetNoWorlds();
//  G4bool found = false;
//  std::vector<G4VPhysicalVolume*>::iterator iterWorld =
//    transportationManager->GetWorldsIterator();
//  for (size_t i = 0; i < nWorlds; ++i, ++iterWorld) {
//    G4VPhysicalVolume* world = (*iterWorld);
//    if (!world) break; // This can happen if geometry has been cleared/destroyed.
//    // The idea now is to seek a PV with the same name and copy no
//    // in the hope it's the same one!!
//    G4PhysicalVolumeModel searchModel (world);
//    G4int verbosity = 0;  // Suppress messages from G4PhysicalVolumeSearchScene.
//    G4PhysicalVolumeSearchScene searchScene
//      (&searchModel, fTopPVName, fTopPVCopyNo, verbosity);
//    G4ModelingParameters mp;  // Default modeling parameters for this search.
//    mp.SetDefaultVisAttributes(fpMP? fpMP->GetDefaultVisAttributes(): 0);
//    searchModel.SetModelingParameters (&mp);
//    searchModel.DescribeYourselfTo (searchScene);
//    G4VPhysicalVolume* foundVolume = searchScene.GetFoundVolume ();
//    if (foundVolume) {
//      if (foundVolume != fpTopPV && warn) {
//  G4cout <<
//    "G4PhysicalVolumeModel::Validate(): A volume of the same name and"
//    "\n  copy number (\""
//         << fTopPVName << "\", copy " << fTopPVCopyNo
//         << ") still exists and is being used."
//    "\n  But it is not the same volume you originally specified"
//    "\n  in /vis/scene/add/."
//         << G4endl;
//      }
//      fpTopPV = foundVolume;
//      CalculateExtent ();
//      found = true;
//    }
//  }
//  if (found) return true;
//  else {
//    if (warn) {
//      G4cout <<
//  "G4PhysicalVolumeModel::Validate(): No volume of name and"
//  "\n  copy number (\""
//       << fTopPVName << "\", copy " << fTopPVCopyNo
//       << ") exists."
//       << G4endl;
//    }
//    return false;
//  }
}

References fpTopPV, G4Exception(), G4PhysicalVolumeStore::GetInstance(), and JustWarning.

Referenced by G4VisCommandSceneAddVolume::SetNewValue().

VisitGeometryAndGetVisReps()

void G4PhysicalVolumeModel::VisitGeometryAndGetVisReps ( G4VPhysicalVolume *  pVPV, G4int  requestedDepth, const G4Transform3D &  theAT, G4VGraphicsScene &  sceneHandler  )

protected

Definition at line 234 of file G4PhysicalVolumeModel.cc.

{
  // Visits geometry structure to a given depth (requestedDepth), starting
  //   at given physical volume with given starting transformation and
  //   describes volumes to the scene handler.
  // requestedDepth < 0 (default) implies full visit.
  // theAT is the Accumulated Transformation.
 
  // Find corresponding logical volume and (later) solid, storing in
  // local variables to preserve re-entrancy.
  G4LogicalVolume* pLV  = pVPV -> GetLogicalVolume ();
  G4VSolid* pSol = nullptr;
  G4Material* pMaterial = nullptr;
 
  if (!(pVPV -> IsReplicated ())) {
    // Non-replicated physical volume.
    pSol = pLV -> GetSolid ();
    pMaterial = pLV -> GetMaterial ();
    DescribeAndDescend (pVPV, requestedDepth, pLV, pSol, pMaterial,
            theAT, sceneHandler);
  }
  else {
    // Replicated or parametrised physical volume.
    EAxis axis;
    G4int nReplicas;
    G4double width;
    G4double offset;
    G4bool consuming;
    pVPV -> GetReplicationData (axis, nReplicas, width,  offset, consuming);
    G4int nBegin = 0;
    G4int nEnd = nReplicas;
    if (fCurrentDepth == 0) { // i.e., top volume
      nBegin = fTopPVCopyNo;  // Describe only one volume, namely the one
      nEnd = nBegin + 1;      // specified by the given copy number.
    }
    G4VPVParameterisation* pP = pVPV -> GetParameterisation ();
    if (pP) {  // Parametrised volume.
      for (int n = nBegin; n < nEnd; n++) {
    pSol = pP -> ComputeSolid (n, pVPV);
    pP -> ComputeTransformation (n, pVPV);
    pSol -> ComputeDimensions (pP, n, pVPV);
    pVPV -> SetCopyNo (n);
        fCurrentPVCopyNo = n;
    // Create a touchable of current parent for ComputeMaterial.
    // fFullPVPath has not been updated yet so at this point it
    // corresponds to the parent.
    G4PhysicalVolumeModelTouchable parentTouchable(fFullPVPath);
    pMaterial = pP -> ComputeMaterial (n, pVPV, &parentTouchable);
    DescribeAndDescend (pVPV, requestedDepth, pLV, pSol, pMaterial,
                theAT, sceneHandler);
      }
    }
    else {  // Plain replicated volume.  From geometry_guide.txt...
      // The replica's positions are claculated by means of a linear formula.
      // Replication may occur along:
      // 
      // o Cartesian axes (kXAxis,kYAxis,kZAxis)
      // 
      //   The replications, of specified width have coordinates of
      //   form (-width*(nReplicas-1)*0.5+n*width,0,0) where n=0.. nReplicas-1
      //   for the case of kXAxis, and are unrotated.
      // 
      // o Radial axis (cylindrical polar) (kRho)
      // 
      //   The replications are cons/tubs sections, centred on the origin
      //   and are unrotated.
      //   They have radii of width*n+offset to width*(n+1)+offset
      //                      where n=0..nReplicas-1
      // 
      // o Phi axis (cylindrical polar) (kPhi)
      //   The replications are `phi sections' or wedges, and of cons/tubs form
      //   They have phi of offset+n*width to offset+(n+1)*width where
      //   n=0..nReplicas-1
      // 
      pSol = pLV -> GetSolid ();
      pMaterial = pLV -> GetMaterial ();
      G4ThreeVector originalTranslation = pVPV -> GetTranslation ();
      G4RotationMatrix* pOriginalRotation = pVPV -> GetRotation ();
      G4double originalRMin = 0., originalRMax = 0.;
      if (axis == kRho && pSol->GetEntityType() == "G4Tubs") {
    originalRMin = ((G4Tubs*)pSol)->GetInnerRadius();
    originalRMax = ((G4Tubs*)pSol)->GetOuterRadius();
      }
      G4bool visualisable = true;
      for (int n = nBegin; n < nEnd; n++) {
    G4ThreeVector translation;  // Identity.
    G4RotationMatrix rotation;  // Identity - life enough for visualizing.
    G4RotationMatrix* pRotation = 0;
    switch (axis) {
    default:
    case kXAxis:
      translation = G4ThreeVector (-width*(nReplicas-1)*0.5+n*width,0,0);
      break;
    case kYAxis:
      translation = G4ThreeVector (0,-width*(nReplicas-1)*0.5+n*width,0);
      break;
    case kZAxis:
      translation = G4ThreeVector (0,0,-width*(nReplicas-1)*0.5+n*width);
      break;
    case kRho:
      if (pSol->GetEntityType() == "G4Tubs") {
        ((G4Tubs*)pSol)->SetInnerRadius(width*n+offset);
        ((G4Tubs*)pSol)->SetOuterRadius(width*(n+1)+offset);
      } else {
        if (fpMP->IsWarning())
          G4cout <<
        "G4PhysicalVolumeModel::VisitGeometryAndGetVisReps: WARNING:"
        "\n  built-in replicated volumes replicated in radius for "
             << pSol->GetEntityType() <<
        "-type\n  solids (your solid \""
             << pSol->GetName() <<
        "\") are not visualisable."
             << G4endl;
        visualisable = false;
      }
      break;
    case kPhi:
      rotation.rotateZ (-(offset+(n+0.5)*width));
      // Minus Sign because for the physical volume we need the
      // coordinate system rotation.
      pRotation = &rotation;
      break;
    } 
    pVPV -> SetTranslation (translation);
    pVPV -> SetRotation    (pRotation);
    pVPV -> SetCopyNo (n);
        fCurrentPVCopyNo = n;
    if (visualisable) {
      DescribeAndDescend (pVPV, requestedDepth, pLV, pSol, pMaterial,
                theAT, sceneHandler);
    }
      }
      // Restore originals...
      pVPV -> SetTranslation (originalTranslation);
      pVPV -> SetRotation    (pOriginalRotation);
      if (axis == kRho && pSol->GetEntityType() == "G4Tubs") {
    ((G4Tubs*)pSol)->SetInnerRadius(originalRMin);
    ((G4Tubs*)pSol)->SetOuterRadius(originalRMax);
      }
    }
  }
}

References DescribeAndDescend(), fCurrentDepth, fCurrentPVCopyNo, fFullPVPath, G4VModel::fpMP, fTopPVCopyNo, G4cout, G4endl, G4VSolid::GetEntityType(), G4VSolid::GetName(), pyG4VTouchable::GetRotation, G4ModelingParameters::IsWarning(), kPhi, kRho, kXAxis, kYAxis, kZAxis, CLHEP::detail::n, and CLHEP::HepRotation::rotateZ().

Referenced by DescribeAndDescend(), and DescribeYourselfTo().

Field Documentation

fAbort

G4bool G4PhysicalVolumeModel::fAbort

mutableprotected

Definition at line 298 of file G4PhysicalVolumeModel.hh.

Referenced by Abort(), DescribeAndDescend(), and DescribeYourselfTo().

fBaseFullPVPath

std::vector<G4PhysicalVolumeNodeID> G4PhysicalVolumeModel::fBaseFullPVPath

protected

Definition at line 295 of file G4PhysicalVolumeModel.hh.

Referenced by CreateCurrentAttValues(), DescribeYourselfTo(), G4PhysicalVolumeModel(), and GetBaseFullPVPath().

fClippingMode

ClippingMode G4PhysicalVolumeModel::fClippingMode

protected

Definition at line 301 of file G4PhysicalVolumeModel.hh.

Referenced by DescribeSolid(), and SetClippingMode().

fCurrentDepth

G4int G4PhysicalVolumeModel::fCurrentDepth

protected

Definition at line 289 of file G4PhysicalVolumeModel.hh.

Referenced by DescribeAndDescend(), DescribeYourselfTo(), GetCurrentDepth(), and VisitGeometryAndGetVisReps().

fCurrentPVCopyNo

G4int G4PhysicalVolumeModel::fCurrentPVCopyNo

protected

Definition at line 291 of file G4PhysicalVolumeModel.hh.

Referenced by DescribeAndDescend(), DescribeYourselfTo(), GetCurrentPVCopyNo(), and VisitGeometryAndGetVisReps().

fCurrentTransform

G4Transform3D G4PhysicalVolumeModel::fCurrentTransform

protected

Definition at line 294 of file G4PhysicalVolumeModel.hh.

Referenced by CreateCurrentAttValues(), DescribeAndDescend(), and GetCurrentTransform().

fCurtailDescent

G4bool G4PhysicalVolumeModel::fCurtailDescent

mutableprotected

Definition at line 299 of file G4PhysicalVolumeModel.hh.

Referenced by CurtailDescent(), DescribeAndDescend(), and DescribeYourselfTo().

fDrawnPVPath

std::vector<G4PhysicalVolumeNodeID> G4PhysicalVolumeModel::fDrawnPVPath

protected

Definition at line 297 of file G4PhysicalVolumeModel.hh.

Referenced by DescribeAndDescend(), DescribeYourselfTo(), and GetDrawnPVPath().

fExtent

G4VisExtent G4VModel::fExtent

protectedinherited

Definition at line 101 of file G4VModel.hh.

Referenced by CalculateExtent(), G4AxesModel::Construct(), G4ArrowModel::G4ArrowModel(), and G4PlotterModel::G4PlotterModel().

fFullPVPath

std::vector<G4PhysicalVolumeNodeID> G4PhysicalVolumeModel::fFullPVPath

protected

Definition at line 296 of file G4PhysicalVolumeModel.hh.

Referenced by CreateCurrentAttValues(), DescribeAndDescend(), DescribeYourselfTo(), GetFullPVPath(), G4PhysicalVolumeModel::G4PhysicalVolumeModelTouchable::GetReplicaNumber(), G4PhysicalVolumeModel::G4PhysicalVolumeModelTouchable::GetRotation(), G4PhysicalVolumeModel::G4PhysicalVolumeModelTouchable::GetSolid(), G4PhysicalVolumeModel::G4PhysicalVolumeModelTouchable::GetTranslation(), G4PhysicalVolumeModel::G4PhysicalVolumeModelTouchable::GetVolume(), and VisitGeometryAndGetVisReps().

fGlobalDescription

G4String G4VModel::fGlobalDescription

protectedinherited

Definition at line 100 of file G4VModel.hh.

Referenced by G4AxesModel::Construct(), G4ArrowModel::G4ArrowModel(), G4DigiModel::G4DigiModel(), G4GPSModel::G4GPSModel(), G4HitsModel::G4HitsModel(), G4LogicalVolumeModel::G4LogicalVolumeModel(), G4PhysicalVolumeModel(), G4PlotterModel::G4PlotterModel(), G4PSHitsModel::G4PSHitsModel(), G4TextModel::G4TextModel(), G4TrajectoriesModel::G4TrajectoriesModel(), G4VFieldModel::G4VFieldModel(), and G4VModel::GetCurrentDescription().

fGlobalTag

G4String G4VModel::fGlobalTag

protectedinherited

Definition at line 99 of file G4VModel.hh.

Referenced by G4AxesModel::Construct(), G4ArrowModel::G4ArrowModel(), G4DigiModel::G4DigiModel(), G4GPSModel::G4GPSModel(), G4HitsModel::G4HitsModel(), G4LogicalVolumeModel::G4LogicalVolumeModel(), G4PhysicalVolumeModel(), G4PlotterModel::G4PlotterModel(), G4PSHitsModel::G4PSHitsModel(), G4TextModel::G4TextModel(), G4TrajectoriesModel::G4TrajectoriesModel(), G4VFieldModel::G4VFieldModel(), GetCurrentTag(), and G4VModel::GetCurrentTag().

fpClippingSolid

G4VSolid* G4PhysicalVolumeModel::fpClippingSolid

protected

Definition at line 300 of file G4PhysicalVolumeModel.hh.

Referenced by DescribeSolid(), GetClippingSolid(), SetClippingSolid(), and ~G4PhysicalVolumeModel().

fpCurrentLV

G4LogicalVolume* G4PhysicalVolumeModel::fpCurrentLV

protected

Definition at line 292 of file G4PhysicalVolumeModel.hh.

Referenced by CreateCurrentAttValues(), DescribeAndDescend(), DescribeYourselfTo(), and GetCurrentLV().

fpCurrentMaterial

G4Material* G4PhysicalVolumeModel::fpCurrentMaterial

protected

Definition at line 293 of file G4PhysicalVolumeModel.hh.

Referenced by CreateCurrentAttValues(), DescribeAndDescend(), DescribeYourselfTo(), and GetCurrentMaterial().

fpCurrentPV

G4VPhysicalVolume* G4PhysicalVolumeModel::fpCurrentPV

protected

Definition at line 290 of file G4PhysicalVolumeModel.hh.

Referenced by CreateCurrentAttValues(), DescribeAndDescend(), DescribeYourselfTo(), GetCurrentPV(), and GetCurrentTag().

fpMP

const G4ModelingParameters* G4VModel::fpMP

protectedinherited

Definition at line 102 of file G4VModel.hh.

Referenced by CalculateExtent(), DescribeAndDescend(), DescribeSolid(), G4DigiModel::DescribeYourselfTo(), G4HitsModel::DescribeYourselfTo(), G4LogicalVolumeModel::DescribeYourselfTo(), DescribeYourselfTo(), G4TrajectoriesModel::DescribeYourselfTo(), G4CallbackModel< F >::DescribeYourselfTo(), and VisitGeometryAndGetVisReps().

fpTopPV

G4VPhysicalVolume* G4PhysicalVolumeModel::fpTopPV

protected

Definition at line 282 of file G4PhysicalVolumeModel.hh.

Referenced by CalculateExtent(), G4LogicalVolumeModel::DescribeYourselfTo(), DescribeYourselfTo(), G4PhysicalVolumeModel(), GetTopPhysicalVolume(), and Validate().

fRequestedDepth

G4int G4PhysicalVolumeModel::fRequestedDepth

protected

Definition at line 285 of file G4PhysicalVolumeModel.hh.

Referenced by CalculateExtent(), DescribeYourselfTo(), GetRequestedDepth(), and SetRequestedDepth().

fTopPVCopyNo

G4int G4PhysicalVolumeModel::fTopPVCopyNo

protected

Definition at line 284 of file G4PhysicalVolumeModel.hh.

Referenced by CalculateExtent(), and VisitGeometryAndGetVisReps().

fTopPVName

G4String G4PhysicalVolumeModel::fTopPVName

protected

Definition at line 283 of file G4PhysicalVolumeModel.hh.

Referenced by G4PhysicalVolumeModel().

fTransform

G4Transform3D G4PhysicalVolumeModel::fTransform

protected

Definition at line 288 of file G4PhysicalVolumeModel.hh.

Referenced by CalculateExtent(), DescribeYourselfTo(), and GetTransformation().

fType

G4String G4VModel::fType

protectedinherited

Definition at line 98 of file G4VModel.hh.

Referenced by G4AxesModel::Construct(), G4ArrowModel::G4ArrowModel(), G4DigiModel::G4DigiModel(), G4GPSModel::G4GPSModel(), G4HitsModel::G4HitsModel(), G4LogicalVolumeModel::G4LogicalVolumeModel(), G4PhysicalVolumeModel(), G4PlotterModel::G4PlotterModel(), G4PSHitsModel::G4PSHitsModel(), G4TextModel::G4TextModel(), G4TrajectoriesModel::G4TrajectoriesModel(), and G4VFieldModel::G4VFieldModel().

fUseFullExtent

G4bool G4PhysicalVolumeModel::fUseFullExtent

protected

Definition at line 287 of file G4PhysicalVolumeModel.hh.

Referenced by CalculateExtent().

---

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

• source/visualization/modeling/include/G4PhysicalVolumeModel.hh
• source/visualization/modeling/src/G4PhysicalVolumeModel.cc