G4LogicalVolumeModel Class Reference

#include <G4LogicalVolumeModel.hh>

Inheritance diagram for G4LogicalVolumeModel:

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 &)
	G4LogicalVolumeModel (G4LogicalVolume *, G4int soughtDepth=1, G4bool booleans=true, G4bool voxels=true, G4bool readout=true, G4bool checkOverlaps=true, const G4Transform3D &modelTransformation=G4Transform3D(), const G4ModelingParameters *=0)
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)
virtual	~G4LogicalVolumeModel ()

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 &)
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
G4bool	fBooleans
G4bool	fCheckOverlaps
ClippingMode	fClippingMode
G4int	fCurrentDepth
G4int	fCurrentPVCopyNo
G4Transform3D	fCurrentTransform
G4bool	fCurtailDescent
std::vector< G4PhysicalVolumeNodeID >	fDrawnPVPath
G4VisExtent	fExtent
std::vector< G4PhysicalVolumeNodeID >	fFullPVPath
G4String	fGlobalDescription
G4String	fGlobalTag
G4bool	fOverlapsPrinted
G4VSolid *	fpClippingSolid
G4LogicalVolume *	fpCurrentLV
G4Material *	fpCurrentMaterial
G4VPhysicalVolume *	fpCurrentPV
G4LogicalVolume *	fpLV
const G4ModelingParameters *	fpMP
G4VPhysicalVolume *	fpTopPV
G4bool	fReadout
G4int	fRequestedDepth
G4int	fTopPVCopyNo
G4String	fTopPVName
G4Transform3D	fTransform
G4String	fType
G4bool	fUseFullExtent
G4bool	fVoxels

Detailed Description

Definition at line 50 of file G4LogicalVolumeModel.hh.

Member Enumeration Documentation

anonymous enum

anonymous enum

inherited

Enumerator
UNLIMITED

Definition at line 86 of file G4PhysicalVolumeModel.hh.

{UNLIMITED = -1};

ClippingMode

enum G4PhysicalVolumeModel::ClippingMode

inherited

Enumerator
subtraction
intersection

Definition at line 88 of file G4PhysicalVolumeModel.hh.

{subtraction, intersection};

Constructor & Destructor Documentation

G4LogicalVolumeModel()

G4LogicalVolumeModel::G4LogicalVolumeModel	(	G4LogicalVolume *	pLV,
		G4int	soughtDepth = 1,
		G4bool	booleans = true,
		G4bool	voxels = true,
		G4bool	readout = true,
		G4bool	checkOverlaps = true,
		const G4Transform3D &	modelTransformation = G4Transform3D(),
		const G4ModelingParameters *	pMP = 0
	)

Definition at line 49 of file G4LogicalVolumeModel.cc.

                                 :
  // Instantiate a G4PhysicalVolumeModel with a G4PVPlacement to
  // represent this logical volume.  It has no rotation and a null
  // translation so that the logical volume will be seen in its own
  // reference system.  It will be added to the physical volume store
  // but it will not be part of the normal geometry heirarchy so it
  // has no mother.
  G4PhysicalVolumeModel
(new G4PVPlacement (0,                   // No rotation.
            G4ThreeVector(),     // Null traslation.
            "PhysVol representation of LogVol " + pLV -> GetName (),
            pLV,
            0,                   // No mother.
            false,               // Not "MANY".
            0),                  // Copy number.
 soughtDepth,
 modelTransformation,
 pMP,
 true),                                  // Use full extent.
  fpLV (pLV),
  fBooleans (booleans),
  fVoxels (voxels),
  fReadout (readout),
  fCheckOverlaps(checkOverlaps),
  fOverlapsPrinted(false)
{
  fType = "G4LogicalVolumeModel";
  fGlobalTag = fpLV -> GetName ();
  fGlobalDescription = "G4LogicalVolumeModel " + fGlobalTag;
}

References G4VModel::fGlobalDescription, G4VModel::fGlobalTag, fpLV, and G4VModel::fType.

~G4LogicalVolumeModel()

G4LogicalVolumeModel::~G4LogicalVolumeModel ( )

virtual

Definition at line 88 of file G4LogicalVolumeModel.cc.

{}

Member Function Documentation

Abort()

void G4PhysicalVolumeModel::Abort ( ) const

inlineinherited

Definition at line 251 of file G4PhysicalVolumeModel.hh.

{fAbort = true;}

References G4PhysicalVolumeModel::fAbort.

Referenced by G4TouchablePropertiesScene::ProcessVolume().

CalculateExtent()

void G4PhysicalVolumeModel::CalculateExtent ( )

inherited

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 G4PhysicalVolumeModel::DescribeYourselfTo(), G4VModel::fExtent, G4VModel::fpMP, G4PhysicalVolumeModel::fpTopPV, G4PhysicalVolumeModel::fRequestedDepth, G4PhysicalVolumeModel::fTopPVCopyNo, G4PhysicalVolumeModel::fTransform, G4PhysicalVolumeModel::fUseFullExtent, G4BoundingExtentScene::GetBoundingExtent(), G4VModel::GetExtent(), G4VisExtent::GetExtentRadius(), G4VisExtent::Transform(), and G4ModelingParameters::wf.

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

CreateCurrentAttValues()

std::vector< G4AttValue > * G4PhysicalVolumeModel::CreateCurrentAttValues ( ) const

inherited

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 G4PhysicalVolumeModel::fBaseFullPVPath, G4PhysicalVolumeModel::fCurrentTransform, G4PhysicalVolumeModel::fFullPVPath, G4PhysicalVolumeModel::fpCurrentLV, G4PhysicalVolumeModel::fpCurrentMaterial, G4PhysicalVolumeModel::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

inlineinherited

Definition at line 254 of file G4PhysicalVolumeModel.hh.

{fCurtailDescent = true;}

References G4PhysicalVolumeModel::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  )

protectedinherited

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, G4PhysicalVolumeModel::DescribeSolid(), HepGeom::Transform3D::dx(), HepGeom::Transform3D::dy(), HepGeom::Transform3D::dz(), G4PhysicalVolumeModel::fAbort, FatalErrorInArgument, G4PhysicalVolumeModel::fCurrentDepth, G4PhysicalVolumeModel::fCurrentPVCopyNo, G4PhysicalVolumeModel::fCurrentTransform, G4PhysicalVolumeModel::fCurtailDescent, G4PhysicalVolumeModel::fDrawnPVPath, G4PhysicalVolumeModel::fFullPVPath, G4PhysicalVolumeModel::fpCurrentLV, G4PhysicalVolumeModel::fpCurrentMaterial, G4PhysicalVolumeModel::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, G4PhysicalVolumeModel::VisitGeometryAndGetVisReps(), anonymous_namespace{G4PhysicalVolumeModel.cc}::volumeCount, and G4VisAttributes::wireframe.

Referenced by G4PhysicalVolumeModel::VisitGeometryAndGetVisReps().

DescribeSolid()

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

protectedvirtual

Reimplemented from G4PhysicalVolumeModel.

Definition at line 292 of file G4LogicalVolumeModel.cc.

                                 {
 
  if (fBooleans) {
    // Look for "constituents".  Could be a Boolean solid.
    G4VSolid* pSol0 = pSol -> GetConstituentSolid (0);
    if (pSol0) {  // Composite solid...
      G4VSolid* pSol1 = pSol -> GetConstituentSolid (1);
      if (!pSol1) {
    G4Exception
      ("G4PhysicalVolumeModel::DescribeSolid",
       "modeling0001", FatalException,
       "2nd component solid in Boolean is missing.");
      }
      // Draw these constituents white and "forced wireframe"...
      G4VisAttributes constituentAttributes;
      constituentAttributes.SetForceWireframe(true);
      DescribeSolid (theAT, pSol0, &constituentAttributes, sceneHandler);
      DescribeSolid (theAT, pSol1, &constituentAttributes, sceneHandler);
    }
  }
 
  // In any case draw the original/resultant solid...
  sceneHandler.PreAddSolid (theAT, *pVisAttribs);
  pSol -> DescribeYourselfTo (sceneHandler);
  sceneHandler.PostAddSolid ();
}

References DescribeSolid(), DescribeYourselfTo(), FatalException, fBooleans, G4Exception(), G4VGraphicsScene::PostAddSolid(), G4VGraphicsScene::PreAddSolid(), and G4VisAttributes::SetForceWireframe().

Referenced by DescribeSolid().

DescribeYourselfTo()

void G4LogicalVolumeModel::DescribeYourselfTo ( G4VGraphicsScene &  sceneHandler )

virtual

Implements G4VModel.

Definition at line 132 of file G4LogicalVolumeModel.cc.

                                 {
 
  // Store current modeling parameters and ensure nothing is culled.
  const G4ModelingParameters* tmpMP = fpMP;
  G4ModelingParameters nonCulledMP;
  if (fpMP) nonCulledMP = *fpMP;
  nonCulledMP.SetCulling (false);
  fpMP = &nonCulledMP;    
  G4PhysicalVolumeModel::DescribeYourselfTo (sceneHandler);
  fpMP = tmpMP;
 
  if (fVoxels) {
    if (fpTopPV->GetLogicalVolume()->GetVoxelHeader()) {
      // Add Voxels.
      G4DrawVoxels dv;
      G4PlacedPolyhedronList* pPPL =
    dv.CreatePlacedPolyhedra (fpTopPV -> GetLogicalVolume ());
      for (size_t i = 0; i < pPPL -> size (); i++) {
    const G4Transform3D& transform = (*pPPL)[i].GetTransform ();
    const G4Polyhedron& polyhedron = (*pPPL)[i].GetPolyhedron ();
    sceneHandler.BeginPrimitives (transform);
    sceneHandler.AddPrimitive (polyhedron);
    sceneHandler.EndPrimitives ();
      }
      delete pPPL;
    }
  }
 
  if (fReadout) {
    // Draw readout geometry...
    G4VSensitiveDetector* sd = fpLV->GetSensitiveDetector();
    if (sd) {
      G4VReadOutGeometry* roGeom = sd->GetROgeometry();
      if (roGeom) {
    G4VPhysicalVolume* roWorld = roGeom->GetROWorld();
    G4cout << "Readout geometry \"" << roGeom->GetName()
           << "\" with top physical volume \""
           << roWorld->GetName()
           << "\"" << G4endl;
    G4PhysicalVolumeModel pvModel(roWorld);
    pvModel.SetModelingParameters(fpMP);
    pvModel.DescribeYourselfTo(sceneHandler);
      }
    }
  }
 
  if (fCheckOverlaps) {
    G4LogicalVolume* motherLog = fpTopPV->GetLogicalVolume();
    G4VSolid* motherSolid = motherLog->GetSolid();
    G4int nDaughters = motherLog->GetNoDaughters();
 
    // Models are called repeatedly by the scene handler so be careful...
    // Print overlaps - but only the first time for a given instantiation of G4LogicalVolume
    if (!fOverlapsPrinted) {
      for (G4int iDaughter = 0; iDaughter < nDaughters; ++iDaughter) {
        G4VPhysicalVolume* daughterPhys = motherLog->GetDaughter(iDaughter);
        daughterPhys->CheckOverlaps();
      }
      fOverlapsPrinted = true;
    }
 
    // Draw overlaps
    solidCopyNoVector.clear();
    for (G4int iDaughter = 0; iDaughter < nDaughters; ++iDaughter) {
      G4VPhysicalVolume* daughterPhys = motherLog->GetDaughter(iDaughter);
      G4PVPlacement* daughterPVPlace = dynamic_cast<G4PVPlacement*>(daughterPhys);
      G4PVParameterised* daughterPVParam = dynamic_cast<G4PVParameterised*>(daughterPhys);
      const G4int nPoints = 1000;
 
      if (daughterPVPlace) {
 
        // This algorithm is based on G4PVPlacement::CheckOverlaps.
        G4AffineTransform tDaughter(daughterPhys->GetRotation(),daughterPhys->GetTranslation());
        G4VSolid* daughterSolid = daughterPhys->GetLogicalVolume()->GetSolid();
        for (G4int i = 0; i < nPoints; ++i) {
          G4ThreeVector point = daughterSolid->GetPointOnSurface();
          // Transform to mother's coordinate system
          G4ThreeVector motherPoint = tDaughter.TransformPoint(point);
          // Check overlaps with the mother volume
          if (motherSolid->Inside(motherPoint)==kOutside) {
            // Draw mother and daughter and point
            DrawSolid(sceneHandler,motherSolid,0,G4Transform3D());
            DrawSolid(sceneHandler,daughterSolid,daughterPhys->GetCopyNo(),tDaughter);
            DrawPoint(sceneHandler,motherPoint);
          }
          // Check other daughters
          for (G4int iSister = 0; iSister < nDaughters; ++iSister) {
            if (iSister == iDaughter) continue;
            G4VPhysicalVolume* sisterPhys = motherLog->GetDaughter(iSister);
            G4AffineTransform tSister(sisterPhys->GetRotation(),sisterPhys->GetTranslation());
            // Transform to sister's coordinate system
            G4ThreeVector sisterPoint = tSister.InverseTransformPoint(motherPoint);
            G4LogicalVolume* sisterLog = sisterPhys->GetLogicalVolume();
            G4VSolid* sisterSolid = sisterLog->GetSolid();
            if (sisterSolid->Inside(sisterPoint)==kInside) {
              // Draw daughter and sister and point
              DrawSolid(sceneHandler,daughterSolid,daughterPhys->GetCopyNo(),tDaughter);
              DrawSolid(sceneHandler,sisterSolid,sisterPhys->GetCopyNo(),tSister);
              DrawPoint(sceneHandler,motherPoint);
            }
          }
        }
 
      } else if (daughterPVParam) {
 
        // This algorithm is based on G4PVParameterised::CheckOverlaps
        const G4int multiplicity = daughterPVParam->GetMultiplicity();
        auto* param = daughterPVParam->GetParameterisation();
        // Cache points for later checking against other parameterisations
        std::vector<G4ThreeVector> motherPoints;
        for (G4int iP = 0; iP < multiplicity; iP++) {
          G4VSolid* daughterSolid = param->ComputeSolid(iP, daughterPhys);
          daughterSolid->ComputeDimensions(param, iP, daughterPhys);
          param->ComputeTransformation(iP, daughterPhys);
          G4AffineTransform tDaughter(daughterPVParam->GetRotation(),daughterPVParam->GetTranslation());
          for (G4int i = 0; i < nPoints; ++i) {
            G4ThreeVector point = daughterSolid->GetPointOnSurface();
            // Transform to mother's coordinate system
            G4ThreeVector motherPoint = tDaughter.TransformPoint(point);
            // Check overlaps with the mother volume
            if (motherSolid->Inside(motherPoint)==kOutside) {
              // Draw mother and daughter and point
              DrawSolid(sceneHandler,motherSolid,0,G4Transform3D());
              DrawSolid(sceneHandler,daughterSolid,iP,tDaughter);
              DrawPoint(sceneHandler,motherPoint);
            }
            motherPoints.push_back(motherPoint);
          }
          // Check sister parameterisations
          for (G4int iPP = iP + 1; iPP < multiplicity; iPP++) {
            G4VSolid* sisterSolid = param->ComputeSolid(iPP, daughterPhys);
            sisterSolid->ComputeDimensions(param, iPP, daughterPhys);
            param->ComputeTransformation(iPP, daughterPhys);
            G4AffineTransform tSister
            (daughterPVParam->GetRotation(),daughterPVParam->GetTranslation());
            for (const auto& motherPoint: motherPoints) {
              // Transform each point into daughter's frame
              G4ThreeVector sisterPoint = tSister.InverseTransformPoint(motherPoint);
              if (sisterSolid->Inside(sisterPoint)==kInside) {
                // Draw sister
                DrawSolid(sceneHandler,sisterSolid,iPP,tSister);
                // Recompute daughter parameterisation before drawing
                daughterSolid->ComputeDimensions(param, iP, daughterPhys);
                param->ComputeTransformation(iP, daughterPhys);
                tDaughter = G4AffineTransform
                (daughterPVParam->GetRotation(),daughterPVParam->GetTranslation());
                DrawSolid(sceneHandler,daughterSolid,iP,tDaughter);
                DrawPoint(sceneHandler,motherPoint);
              }
            }
          }
        }
      }
    }
  }
}

References G4VGraphicsScene::AddPrimitive(), G4VGraphicsScene::BeginPrimitives(), G4VPhysicalVolume::CheckOverlaps(), G4VSolid::ComputeDimensions(), G4DrawVoxels::CreatePlacedPolyhedra(), G4PhysicalVolumeModel::DescribeYourselfTo(), anonymous_namespace{G4LogicalVolumeModel.cc}::DrawPoint(), anonymous_namespace{G4LogicalVolumeModel.cc}::DrawSolid(), G4VGraphicsScene::EndPrimitives(), fCheckOverlaps, fOverlapsPrinted, fpLV, G4VModel::fpMP, G4PhysicalVolumeModel::fpTopPV, fReadout, fVoxels, G4cout, G4endl, G4VPhysicalVolume::GetCopyNo(), G4LogicalVolume::GetDaughter(), G4VPhysicalVolume::GetLogicalVolume(), G4PVReplica::GetMultiplicity(), G4VReadOutGeometry::GetName(), G4VPhysicalVolume::GetName(), G4LogicalVolume::GetNoDaughters(), G4PVParameterised::GetParameterisation(), G4VSolid::GetPointOnSurface(), G4VSensitiveDetector::GetROgeometry(), G4VPhysicalVolume::GetRotation(), G4VReadOutGeometry::GetROWorld(), G4LogicalVolume::GetSensitiveDetector(), G4LogicalVolume::GetSolid(), G4VPhysicalVolume::GetTranslation(), G4LogicalVolume::GetVoxelHeader(), G4VSolid::Inside(), G4AffineTransform::InverseTransformPoint(), kInside, kOutside, G4ModelingParameters::SetCulling(), G4VModel::SetModelingParameters(), anonymous_namespace{G4LogicalVolumeModel.cc}::solidCopyNoVector, G4coutFormatters::anonymous_namespace{G4coutFormatters.cc}::transform(), and G4AffineTransform::TransformPoint().

Referenced by DescribeSolid().

GetAttDefs()

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

inherited

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

inlineinherited

Definition at line 198 of file G4PhysicalVolumeModel.hh.

  {return fBaseFullPVPath;}

References G4PhysicalVolumeModel::fBaseFullPVPath.

GetClippingSolid()

const G4VSolid * G4PhysicalVolumeModel::GetClippingSolid ( ) const

inlineinherited

Definition at line 174 of file G4PhysicalVolumeModel.hh.

  {return fpClippingSolid;}

References G4PhysicalVolumeModel::fpClippingSolid.

GetCurrentDepth()

G4int G4PhysicalVolumeModel::GetCurrentDepth ( ) const

inlineinherited

Definition at line 177 of file G4PhysicalVolumeModel.hh.

{return fCurrentDepth;}

References G4PhysicalVolumeModel::fCurrentDepth.

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

GetCurrentDescription()

G4String G4PhysicalVolumeModel::GetCurrentDescription ( ) const

virtualinherited

Reimplemented from G4VModel.

Definition at line 229 of file G4PhysicalVolumeModel.cc.

{
  return "G4PhysicalVolumeModel " + GetCurrentTag ();
}

References G4PhysicalVolumeModel::GetCurrentTag().

GetCurrentLV()

G4LogicalVolume * G4PhysicalVolumeModel::GetCurrentLV ( ) const

inlineinherited

Definition at line 189 of file G4PhysicalVolumeModel.hh.

{return fpCurrentLV;}

References G4PhysicalVolumeModel::fpCurrentLV.

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

GetCurrentMaterial()

G4Material * G4PhysicalVolumeModel::GetCurrentMaterial ( ) const

inlineinherited

Definition at line 192 of file G4PhysicalVolumeModel.hh.

{return fpCurrentMaterial;}

References G4PhysicalVolumeModel::fpCurrentMaterial.

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

GetCurrentPV()

G4VPhysicalVolume * G4PhysicalVolumeModel::GetCurrentPV ( ) const

inlineinherited

Definition at line 183 of file G4PhysicalVolumeModel.hh.

{return fpCurrentPV;}

References G4PhysicalVolumeModel::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

inlineinherited

Definition at line 186 of file G4PhysicalVolumeModel.hh.

{return fCurrentPVCopyNo;}

References G4PhysicalVolumeModel::fCurrentPVCopyNo.

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

GetCurrentTag()

G4String G4PhysicalVolumeModel::GetCurrentTag ( ) const

virtualinherited

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 G4PhysicalVolumeModel::fpCurrentPV.

Referenced by G4PhysicalVolumeModel::GetCurrentDescription().

GetCurrentTransform()

const G4Transform3D & G4PhysicalVolumeModel::GetCurrentTransform ( ) const

inlineinherited

Definition at line 195 of file G4PhysicalVolumeModel.hh.

{return fCurrentTransform;}

References G4PhysicalVolumeModel::fCurrentTransform.

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

GetDrawnPVPath()

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

inlineinherited

Definition at line 212 of file G4PhysicalVolumeModel.hh.

  {return fDrawnPVPath;}

References G4PhysicalVolumeModel::fDrawnPVPath.

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

GetExtent()

const G4VisExtent & G4VModel::GetExtent ( ) const

inherited

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

GetFullPVPath()

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

inlineinherited

Definition at line 205 of file G4PhysicalVolumeModel.hh.

  {return fFullPVPath;}

References G4PhysicalVolumeModel::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 )

staticinherited

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

inlineinherited

Definition at line 172 of file G4PhysicalVolumeModel.hh.

{return fRequestedDepth;}

References G4PhysicalVolumeModel::fRequestedDepth.

Referenced by G4ASCIITreeSceneHandler::EndModeling().

GetTopPhysicalVolume()

G4VPhysicalVolume * G4PhysicalVolumeModel::GetTopPhysicalVolume ( ) const

inlineinherited

Definition at line 170 of file G4PhysicalVolumeModel.hh.

{return fpTopPV;}

References G4PhysicalVolumeModel::fpTopPV.

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

GetTransformation()

const G4Transform3D & G4PhysicalVolumeModel::GetTransformation ( ) const

inlineinherited

Definition at line 180 of file G4PhysicalVolumeModel.hh.

{return fTransform;}

References G4PhysicalVolumeModel::fTransform.

Referenced by G4OpenGLQtViewer::parseAndInsertInSceneTree().

GetType()

const G4String & G4VModel::GetType ( ) const

inherited

Referenced by G4OpenGLStoredQtSceneHandler::ExtraPOProcessing().

SetClippingMode()

void G4PhysicalVolumeModel::SetClippingMode ( ClippingMode  mode )

inlineinherited

Definition at line 244 of file G4PhysicalVolumeModel.hh.

                                           {
    fClippingMode = mode;
  }

References G4PhysicalVolumeModel::fClippingMode.

Referenced by G4VisCommandSceneAddVolume::SetNewValue().

SetClippingSolid()

void G4PhysicalVolumeModel::SetClippingSolid ( G4VSolid *  pClippingSolid )

inlineinherited

Definition at line 240 of file G4PhysicalVolumeModel.hh.

                                                   {
    fpClippingSolid = pClippingSolid;
  }

References G4PhysicalVolumeModel::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 DescribeYourselfTo(), G4ASCIITreeSceneHandler::EndModeling(), G4TouchableUtils::FindTouchableProperties(), G4VSceneHandler::ProcessScene(), G4VisCommandSetTouchable::SetNewValue(), G4VisCommandSetVolumeForField::SetNewValue(), G4VisCommandsTouchable::SetNewValue(), and G4VisCommandViewerCentreOn::SetNewValue().

SetRequestedDepth()

void G4PhysicalVolumeModel::SetRequestedDepth ( G4int  requestedDepth )

inlineinherited

Definition at line 236 of file G4PhysicalVolumeModel.hh.

                                                {
    fRequestedDepth = requestedDepth;
  }

References G4PhysicalVolumeModel::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 G4LogicalVolumeModel::Validate ( G4bool  )

inlinevirtual

Reimplemented from G4VModel.

Definition at line 68 of file G4LogicalVolumeModel.hh.

{return true;}

VisitGeometryAndGetVisReps()

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

protectedinherited

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 G4PhysicalVolumeModel::DescribeAndDescend(), G4PhysicalVolumeModel::fCurrentDepth, G4PhysicalVolumeModel::fCurrentPVCopyNo, G4PhysicalVolumeModel::fFullPVPath, G4VModel::fpMP, G4PhysicalVolumeModel::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 G4PhysicalVolumeModel::DescribeAndDescend(), and G4PhysicalVolumeModel::DescribeYourselfTo().

Field Documentation

fAbort

G4bool G4PhysicalVolumeModel::fAbort

mutableprotectedinherited

Definition at line 298 of file G4PhysicalVolumeModel.hh.

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

fBaseFullPVPath

std::vector<G4PhysicalVolumeNodeID> G4PhysicalVolumeModel::fBaseFullPVPath

protectedinherited

Definition at line 295 of file G4PhysicalVolumeModel.hh.

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

fBooleans

G4bool G4LogicalVolumeModel::fBooleans

protected

Definition at line 84 of file G4LogicalVolumeModel.hh.

Referenced by DescribeSolid().

fCheckOverlaps

G4bool G4LogicalVolumeModel::fCheckOverlaps

protected

Definition at line 87 of file G4LogicalVolumeModel.hh.

Referenced by DescribeYourselfTo().

fClippingMode

ClippingMode G4PhysicalVolumeModel::fClippingMode

protectedinherited

Definition at line 301 of file G4PhysicalVolumeModel.hh.

Referenced by G4PhysicalVolumeModel::DescribeSolid(), and G4PhysicalVolumeModel::SetClippingMode().

fCurrentDepth

G4int G4PhysicalVolumeModel::fCurrentDepth

protectedinherited

Definition at line 289 of file G4PhysicalVolumeModel.hh.

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

fCurrentPVCopyNo

G4int G4PhysicalVolumeModel::fCurrentPVCopyNo

protectedinherited

Definition at line 291 of file G4PhysicalVolumeModel.hh.

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

fCurrentTransform

G4Transform3D G4PhysicalVolumeModel::fCurrentTransform

protectedinherited

Definition at line 294 of file G4PhysicalVolumeModel.hh.

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

fCurtailDescent

G4bool G4PhysicalVolumeModel::fCurtailDescent

mutableprotectedinherited

Definition at line 299 of file G4PhysicalVolumeModel.hh.

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

fDrawnPVPath

std::vector<G4PhysicalVolumeNodeID> G4PhysicalVolumeModel::fDrawnPVPath

protectedinherited

Definition at line 297 of file G4PhysicalVolumeModel.hh.

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

fExtent

G4VisExtent G4VModel::fExtent

protectedinherited

Definition at line 101 of file G4VModel.hh.

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

fFullPVPath

std::vector<G4PhysicalVolumeNodeID> G4PhysicalVolumeModel::fFullPVPath

protectedinherited

Definition at line 296 of file G4PhysicalVolumeModel.hh.

Referenced by G4PhysicalVolumeModel::CreateCurrentAttValues(), G4PhysicalVolumeModel::DescribeAndDescend(), G4PhysicalVolumeModel::DescribeYourselfTo(), G4PhysicalVolumeModel::GetFullPVPath(), G4PhysicalVolumeModel::G4PhysicalVolumeModelTouchable::GetReplicaNumber(), G4PhysicalVolumeModel::G4PhysicalVolumeModelTouchable::GetRotation(), G4PhysicalVolumeModel::G4PhysicalVolumeModelTouchable::GetSolid(), G4PhysicalVolumeModel::G4PhysicalVolumeModelTouchable::GetTranslation(), G4PhysicalVolumeModel::G4PhysicalVolumeModelTouchable::GetVolume(), and G4PhysicalVolumeModel::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(), G4PhysicalVolumeModel::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(), G4PhysicalVolumeModel::G4PhysicalVolumeModel(), G4PlotterModel::G4PlotterModel(), G4PSHitsModel::G4PSHitsModel(), G4TextModel::G4TextModel(), G4TrajectoriesModel::G4TrajectoriesModel(), G4VFieldModel::G4VFieldModel(), G4PhysicalVolumeModel::GetCurrentTag(), and G4VModel::GetCurrentTag().

fOverlapsPrinted

G4bool G4LogicalVolumeModel::fOverlapsPrinted

protected

Definition at line 88 of file G4LogicalVolumeModel.hh.

Referenced by DescribeYourselfTo().

fpClippingSolid

G4VSolid* G4PhysicalVolumeModel::fpClippingSolid

protectedinherited

Definition at line 300 of file G4PhysicalVolumeModel.hh.

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

fpCurrentLV

G4LogicalVolume* G4PhysicalVolumeModel::fpCurrentLV

protectedinherited

Definition at line 292 of file G4PhysicalVolumeModel.hh.

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

fpCurrentMaterial

G4Material* G4PhysicalVolumeModel::fpCurrentMaterial

protectedinherited

Definition at line 293 of file G4PhysicalVolumeModel.hh.

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

fpCurrentPV

G4VPhysicalVolume* G4PhysicalVolumeModel::fpCurrentPV

protectedinherited

Definition at line 290 of file G4PhysicalVolumeModel.hh.

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

fpLV

G4LogicalVolume* G4LogicalVolumeModel::fpLV

protected

Definition at line 83 of file G4LogicalVolumeModel.hh.

Referenced by DescribeYourselfTo(), and G4LogicalVolumeModel().

fpMP

const G4ModelingParameters* G4VModel::fpMP

protectedinherited

Definition at line 102 of file G4VModel.hh.

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

fpTopPV

G4VPhysicalVolume* G4PhysicalVolumeModel::fpTopPV

protectedinherited

Definition at line 282 of file G4PhysicalVolumeModel.hh.

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

fReadout

G4bool G4LogicalVolumeModel::fReadout

protected

Definition at line 86 of file G4LogicalVolumeModel.hh.

Referenced by DescribeYourselfTo().

fRequestedDepth

G4int G4PhysicalVolumeModel::fRequestedDepth

protectedinherited

Definition at line 285 of file G4PhysicalVolumeModel.hh.

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

fTopPVCopyNo

G4int G4PhysicalVolumeModel::fTopPVCopyNo

protectedinherited

Definition at line 284 of file G4PhysicalVolumeModel.hh.

Referenced by G4PhysicalVolumeModel::CalculateExtent(), and G4PhysicalVolumeModel::VisitGeometryAndGetVisReps().

fTopPVName

G4String G4PhysicalVolumeModel::fTopPVName

protectedinherited

Definition at line 283 of file G4PhysicalVolumeModel.hh.

Referenced by G4PhysicalVolumeModel::G4PhysicalVolumeModel().

fTransform

G4Transform3D G4PhysicalVolumeModel::fTransform

protectedinherited

Definition at line 288 of file G4PhysicalVolumeModel.hh.

Referenced by G4PhysicalVolumeModel::CalculateExtent(), G4PhysicalVolumeModel::DescribeYourselfTo(), and G4PhysicalVolumeModel::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(), G4PhysicalVolumeModel::G4PhysicalVolumeModel(), G4PlotterModel::G4PlotterModel(), G4PSHitsModel::G4PSHitsModel(), G4TextModel::G4TextModel(), G4TrajectoriesModel::G4TrajectoriesModel(), and G4VFieldModel::G4VFieldModel().

fUseFullExtent

G4bool G4PhysicalVolumeModel::fUseFullExtent

protectedinherited

Definition at line 287 of file G4PhysicalVolumeModel.hh.

Referenced by G4PhysicalVolumeModel::CalculateExtent().

fVoxels

G4bool G4LogicalVolumeModel::fVoxels

protected

Definition at line 85 of file G4LogicalVolumeModel.hh.

Referenced by DescribeYourselfTo().

---

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

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