G4LogicalVolumeModel Class Reference

#include <G4LogicalVolumeModel.hh>

Inheritance diagram for G4LogicalVolumeModel:

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

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

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

Additional Inherited Members
Public Types inherited from G4PhysicalVolumeModel
enum	{ UNLIMITED = -1 }
enum	ClippingMode { subtraction , intersection }
Static Public Member Functions inherited from G4PhysicalVolumeModel
static G4ModelingParameters::PVNameCopyNoPath	GetPVNameCopyNoPath (const std::vector< G4PhysicalVolumeNodeID > &)

Detailed Description

Definition at line 50 of file G4LogicalVolumeModel.hh.

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;
}

~G4LogicalVolumeModel()

G4LogicalVolumeModel::~G4LogicalVolumeModel ( )

virtual

Definition at line 88 of file G4LogicalVolumeModel.cc.

{}

Member Function Documentation

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 ();
}

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 = (G4int)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);
              }
            }
          }
        }
      }
    }
  }
}

Referenced by DescribeSolid().

Validate()

G4bool G4LogicalVolumeModel::Validate ( G4bool  )

inlinevirtual

Reimplemented from G4VModel.

Definition at line 68 of file G4LogicalVolumeModel.hh.

{return true;}

Member Data Documentation

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().

fOverlapsPrinted

G4bool G4LogicalVolumeModel::fOverlapsPrinted

protected

Definition at line 88 of file G4LogicalVolumeModel.hh.

Referenced by DescribeYourselfTo().

fpLV

G4LogicalVolume* G4LogicalVolumeModel::fpLV

protected

Definition at line 83 of file G4LogicalVolumeModel.hh.

Referenced by DescribeYourselfTo(), and G4LogicalVolumeModel().

fReadout

G4bool G4LogicalVolumeModel::fReadout

protected

Definition at line 86 of file G4LogicalVolumeModel.hh.

Referenced by DescribeYourselfTo().

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:

• G4LogicalVolumeModel.hh
• G4LogicalVolumeModel.cc