Geant4 11.4.0
Toolkit for the simulation of the passage of particles through matter
Loading...
Searching...
No Matches
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
const std::map< G4int, G4int > & GetMapOfDrawnTouchables () const
G4int GetTotalDrawnTouchables ()
G4int GetMaxFullDepth () const
const std::map< G4int, G4int > & GetMapOfAllTouchables () const
G4int GetTotalAllTouchables ()
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 ()
const G4ModelingParameters * GetModelingParameters () const
const G4String & GetType () 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 &)

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 &)

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
G4int fNClippers
std::map< G4int, G4int > fMapDrawnTouchables
G4int fTotalDrawnTouchables
std::map< G4int, G4int > fMapAllTouchables
G4int fTotalAllTouchables
G4int fMaxFullDepth
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 > &)
static G4String GetPVNamePathString (const std::vector< G4PhysicalVolumeNodeID > &)
Static Public Member Functions inherited from G4VModel
static const G4ModelingParameters * GetCurrentModelingParameters ()
static void SetCurrentModelingParameters (const G4ModelingParameters *)

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.

57 :
58 // Instantiate a G4PhysicalVolumeModel with a G4PVPlacement to
59 // represent this logical volume. It has no rotation and a null
60 // translation so that the logical volume will be seen in its own
61 // reference system. It will be added to the physical volume store
62 // but it will not be part of the normal geometry heirarchy so it
63 // has no mother.
64 G4PhysicalVolumeModel
65(new G4PVPlacement (0, // No rotation.
66 G4ThreeVector(), // Null traslation.
67 "PhysVol representation of LogVol " + pLV -> GetName (),
68 pLV,
69 0, // No mother.
70 false, // Not "MANY".
71 0), // Copy number.
72 soughtDepth,
73 modelTransformation,
74 pMP,
75 true), // Use full extent.
76 fpLV (pLV),
77 fBooleans (booleans),
78 fVoxels (voxels),
79 fReadout (readout),
80 fCheckOverlaps(checkOverlaps),
81 fOverlapsPrinted(false)
82{
83 fType = "G4LogicalVolumeModel";
84 fGlobalTag = fpLV -> GetName ();
85 fGlobalDescription = "G4LogicalVolumeModel " + fGlobalTag;
86}
G4ThreeVector
CLHEP::Hep3Vector G4ThreeVector
Definition G4ThreeVector.hh:36
G4PhysicalVolumeModel::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 >())
Definition G4PhysicalVolumeModel.cc:63
G4VModel::fGlobalDescription
G4String fGlobalDescription
Definition G4VModel.hh:106
G4VModel::fType
G4String fType
Definition G4VModel.hh:104
G4VModel::fGlobalTag
G4String fGlobalTag
Definition G4VModel.hh:105

◆ ~G4LogicalVolumeModel()

G4LogicalVolumeModel::~G4LogicalVolumeModel ( )
virtual

Definition at line 88 of file G4LogicalVolumeModel.cc.

88{}

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.

296 {
297
298 if (fBooleans) {
299 // Look for "constituents". Could be a Boolean solid.
300 G4VSolid* pSol0 = pSol -> GetConstituentSolid (0);
301 if (pSol0) { // Composite solid...
302 G4VSolid* pSol1 = pSol -> GetConstituentSolid (1);
303 if (!pSol1) {
304 G4Exception
305 ("G4PhysicalVolumeModel::DescribeSolid",
306 "modeling0001", FatalException,
307 "2nd component solid in Boolean is missing.");
308 }
309 // Draw these constituents white and "forced wireframe"...
310 G4VisAttributes constituentAttributes;
311 constituentAttributes.SetForceWireframe(true);
312 DescribeSolid (theAT, pSol0, &constituentAttributes, sceneHandler);
313 DescribeSolid (theAT, pSol1, &constituentAttributes, sceneHandler);
314 }
315 }
316
317 // In any case draw the original/resultant solid...
318 sceneHandler.PreAddSolid (theAT, *pVisAttribs);
319 pSol -> DescribeYourselfTo (sceneHandler);
320 sceneHandler.PostAddSolid ();
321}
FatalException
@ FatalException
Definition G4ExceptionSeverity.hh:67
G4Exception
void G4Exception(const char *originOfException, const char *exceptionCode, G4ExceptionSeverity severity, const char *description)
Definition G4Exception.cc:59
G4LogicalVolumeModel::DescribeYourselfTo
void DescribeYourselfTo(G4VGraphicsScene &)
Definition G4LogicalVolumeModel.cc:133
G4LogicalVolumeModel::DescribeSolid
void DescribeSolid(const G4Transform3D &theAT, G4VSolid *pSol, const G4VisAttributes *pVisAttribs, G4VGraphicsScene &sceneHandler)
Definition G4LogicalVolumeModel.cc:293
G4VGraphicsScene::PostAddSolid
virtual void PostAddSolid()=0
G4VGraphicsScene::PreAddSolid
virtual void PreAddSolid(const G4Transform3D &objectTransformation, const G4VisAttributes &visAttribs)=0
G4VisAttributes::SetForceWireframe
void SetForceWireframe(G4bool=true)
Definition G4VisAttributes.cc:140

Referenced by DescribeSolid().

◆ DescribeYourselfTo()

void G4LogicalVolumeModel::DescribeYourselfTo ( G4VGraphicsScene & sceneHandler)
virtual

Implements G4VModel.

Definition at line 132 of file G4LogicalVolumeModel.cc.

133 {
134
135 // Store current modeling parameters and ensure nothing is culled.
136 const G4ModelingParameters* tmpMP = fpMP;
137 G4ModelingParameters nonCulledMP;
138 if (fpMP) nonCulledMP = *fpMP;
139 nonCulledMP.SetCulling (false);
140 fpMP = &nonCulledMP;
141 G4PhysicalVolumeModel::DescribeYourselfTo (sceneHandler);
142 fpMP = tmpMP;
143
144 if (fVoxels) {
145 if (fpTopPV->GetLogicalVolume()->GetVoxelHeader()) {
146 // Add Voxels.
147 G4DrawVoxels dv;
148 G4PlacedPolyhedronList* pPPL =
149 dv.CreatePlacedPolyhedra (fpTopPV -> GetLogicalVolume ());
150 for (size_t i = 0; i < pPPL -> size (); i++) {
151 const G4Transform3D& transform = (*pPPL)[i].GetTransform ();
152 const G4Polyhedron& polyhedron = (*pPPL)[i].GetPolyhedron ();
153 sceneHandler.BeginPrimitives (transform);
154 sceneHandler.AddPrimitive (polyhedron);
155 sceneHandler.EndPrimitives ();
156 }
157 delete pPPL;
158 }
159 }
160
161 if (fReadout) {
162 // Draw readout geometry...
163 G4VSensitiveDetector* sd = fpLV->GetSensitiveDetector();
164 if (sd) {
165 G4VReadOutGeometry* roGeom = sd->GetROgeometry();
166 if (roGeom) {
167 G4VPhysicalVolume* roWorld = roGeom->GetROWorld();
168// G4cout << "Readout geometry \"" << roGeom->GetName()
169// << "\" with top physical volume \""
170// << roWorld->GetName()
171// << "\"" << G4endl;
172 G4PhysicalVolumeModel pvModel(roWorld);
173 pvModel.SetModelingParameters(fpMP);
174 pvModel.DescribeYourselfTo(sceneHandler);
175 }
176 }
177 }
178
179 if (fCheckOverlaps) {
180 G4LogicalVolume* motherLog = fpTopPV->GetLogicalVolume();
181 G4VSolid* motherSolid = motherLog->GetSolid();
182 G4int nDaughters = (G4int)motherLog->GetNoDaughters();
183
184 // Models are called repeatedly by the scene handler so be careful...
185 // Print overlaps - but only the first time for a given instantiation of G4LogicalVolume
186 if (!fOverlapsPrinted) {
187 for (G4int iDaughter = 0; iDaughter < nDaughters; ++iDaughter) {
188 G4VPhysicalVolume* daughterPhys = motherLog->GetDaughter(iDaughter);
189 daughterPhys->CheckOverlaps();
190 }
191 fOverlapsPrinted = true;
192 }
193
194 // Draw overlaps
195 solidCopyNoVector.clear();
196 for (G4int iDaughter = 0; iDaughter < nDaughters; ++iDaughter) {
197 G4VPhysicalVolume* daughterPhys = motherLog->GetDaughter(iDaughter);
198 G4PVPlacement* daughterPVPlace = dynamic_cast<G4PVPlacement*>(daughterPhys);
199 G4PVParameterised* daughterPVParam = dynamic_cast<G4PVParameterised*>(daughterPhys);
200 const G4int nPoints = 1000;
201
202 if (daughterPVPlace) {
203
204 // This algorithm is based on G4PVPlacement::CheckOverlaps.
205 G4AffineTransform tDaughter(daughterPhys->GetRotation(),daughterPhys->GetTranslation());
206 G4VSolid* daughterSolid = daughterPhys->GetLogicalVolume()->GetSolid();
207 for (G4int i = 0; i < nPoints; ++i) {
208 G4ThreeVector point = daughterSolid->GetPointOnSurface();
209 // Transform to mother's coordinate system
210 G4ThreeVector motherPoint = tDaughter.TransformPoint(point);
211 // Check overlaps with the mother volume
212 if (motherSolid->Inside(motherPoint)==kOutside) {
213 // Draw mother and daughter and point
214 DrawSolid(sceneHandler,motherSolid,0,G4Transform3D());
215 DrawSolid(sceneHandler,daughterSolid,daughterPhys->GetCopyNo(),tDaughter);
216 DrawPoint(sceneHandler,motherPoint);
217 }
218 // Check other daughters
219 for (G4int iSister = 0; iSister < nDaughters; ++iSister) {
220 if (iSister == iDaughter) continue;
221 G4VPhysicalVolume* sisterPhys = motherLog->GetDaughter(iSister);
222 G4AffineTransform tSister(sisterPhys->GetRotation(),sisterPhys->GetTranslation());
223 // Transform to sister's coordinate system
224 G4ThreeVector sisterPoint = tSister.InverseTransformPoint(motherPoint);
225 G4LogicalVolume* sisterLog = sisterPhys->GetLogicalVolume();
226 G4VSolid* sisterSolid = sisterLog->GetSolid();
227 if (sisterSolid->Inside(sisterPoint)==kInside) {
228 // Draw daughter and sister and point
229 DrawSolid(sceneHandler,daughterSolid,daughterPhys->GetCopyNo(),tDaughter);
230 DrawSolid(sceneHandler,sisterSolid,sisterPhys->GetCopyNo(),tSister);
231 DrawPoint(sceneHandler,motherPoint);
232 }
233 }
234 }
235
236 } else if (daughterPVParam) {
237
238 // This algorithm is based on G4PVParameterised::CheckOverlaps
239 const G4int multiplicity = daughterPVParam->GetMultiplicity();
240 auto* param = daughterPVParam->GetParameterisation();
241 // Cache points for later checking against other parameterisations
242 std::vector<G4ThreeVector> motherPoints;
243 for (G4int iP = 0; iP < multiplicity; iP++) {
244 G4VSolid* daughterSolid = param->ComputeSolid(iP, daughterPhys);
245 daughterSolid->ComputeDimensions(param, iP, daughterPhys);
246 param->ComputeTransformation(iP, daughterPhys);
247 G4AffineTransform tDaughter(daughterPVParam->GetRotation(),daughterPVParam->GetTranslation());
248 for (G4int i = 0; i < nPoints; ++i) {
249 G4ThreeVector point = daughterSolid->GetPointOnSurface();
250 // Transform to mother's coordinate system
251 G4ThreeVector motherPoint = tDaughter.TransformPoint(point);
252 // Check overlaps with the mother volume
253 if (motherSolid->Inside(motherPoint)==kOutside) {
254 // Draw mother and daughter and point
255 DrawSolid(sceneHandler,motherSolid,0,G4Transform3D());
256 DrawSolid(sceneHandler,daughterSolid,iP,tDaughter);
257 DrawPoint(sceneHandler,motherPoint);
258 }
259 motherPoints.push_back(motherPoint);
260 }
261 // Check sister parameterisations
262 for (G4int iPP = iP + 1; iPP < multiplicity; iPP++) {
263 G4VSolid* sisterSolid = param->ComputeSolid(iPP, daughterPhys);
264 sisterSolid->ComputeDimensions(param, iPP, daughterPhys);
265 param->ComputeTransformation(iPP, daughterPhys);
266 G4AffineTransform tSister
267 (daughterPVParam->GetRotation(),daughterPVParam->GetTranslation());
268 for (const auto& motherPoint: motherPoints) {
269 // Transform each point into daughter's frame
270 G4ThreeVector sisterPoint = tSister.InverseTransformPoint(motherPoint);
271 if (sisterSolid->Inside(sisterPoint)==kInside) {
272 // Draw sister
273 DrawSolid(sceneHandler,sisterSolid,iPP,tSister);
274 // Recompute daughter parameterisation before drawing
275 daughterSolid->ComputeDimensions(param, iP, daughterPhys);
276 param->ComputeTransformation(iP, daughterPhys);
277 tDaughter = G4AffineTransform
278 (daughterPVParam->GetRotation(),daughterPVParam->GetTranslation());
279 DrawSolid(sceneHandler,daughterSolid,iP,tDaughter);
280 DrawPoint(sceneHandler,motherPoint);
281 }
282 }
283 }
284 }
285 }
286 }
287 }
288}
G4PlacedPolyhedronList
std::vector< G4PlacedPolyhedron > G4PlacedPolyhedronList
Definition G4PlacedPolyhedron.hh:72
G4Transform3D
HepGeom::Transform3D G4Transform3D
Definition G4Transform3D.hh:33
G4int
int G4int
Definition G4Types.hh:85
G4DrawVoxels::CreatePlacedPolyhedra
G4PlacedPolyhedronList * CreatePlacedPolyhedra(const G4LogicalVolume *) const
Definition G4DrawVoxels.cc:179
G4LogicalVolume::GetSolid
G4VSolid * GetSolid() const
Definition G4LogicalVolume.cc:417
G4LogicalVolume::GetNoDaughters
std::size_t GetNoDaughters() const
G4LogicalVolume::GetDaughter
G4VPhysicalVolume * GetDaughter(const std::size_t i) const
G4ModelingParameters::SetCulling
void SetCulling(G4bool)
G4PVParameterised::GetParameterisation
G4VPVParameterisation * GetParameterisation() const override
Definition G4PVParameterised.cc:116
G4PhysicalVolumeModel::DescribeYourselfTo
void DescribeYourselfTo(G4VGraphicsScene &)
Definition G4PhysicalVolumeModel.cc:195
G4VGraphicsScene::BeginPrimitives
virtual void BeginPrimitives(const G4Transform3D &objectTransformation=G4Transform3D())=0
G4VGraphicsScene::AddPrimitive
virtual void AddPrimitive(const G4Polyline &)=0
G4VGraphicsScene::EndPrimitives
virtual void EndPrimitives()=0
G4VModel::fpMP
const G4ModelingParameters * fpMP
Definition G4VModel.hh:108
G4VPhysicalVolume::GetRotation
const G4RotationMatrix * GetRotation() const
Definition G4VPhysicalVolume.cc:160
G4VPhysicalVolume::GetTranslation
const G4ThreeVector GetTranslation() const
Definition G4VPhysicalVolume.cc:150
G4VPhysicalVolume::CheckOverlaps
virtual G4bool CheckOverlaps(G4int res=1000, G4double tol=0., G4bool verbose=true, G4int errMax=1)
Definition G4VPhysicalVolume.cc:221
G4VPhysicalVolume::GetLogicalVolume
G4LogicalVolume * GetLogicalVolume() const
G4VPhysicalVolume::GetCopyNo
virtual G4int GetCopyNo() const =0
G4VReadOutGeometry::GetROWorld
G4VPhysicalVolume * GetROWorld() const
Definition G4VReadOutGeometry.hh:62
G4VSensitiveDetector::GetROgeometry
G4VReadOutGeometry * GetROgeometry() const
Definition G4VSensitiveDetector.hh:110
G4VSolid::Inside
virtual EInside Inside(const G4ThreeVector &p) const =0
G4VSolid::ComputeDimensions
virtual void ComputeDimensions(G4VPVParameterisation *p, const G4int n, const G4VPhysicalVolume *pRep)
Definition G4VSolid.cc:136
G4VSolid::GetPointOnSurface
virtual G4ThreeVector GetPointOnSurface() const
Definition G4VSolid.cc:151
kInside
@ kInside
Definition geomdefs.hh:70
kOutside
@ kOutside
Definition geomdefs.hh:68

Referenced by DescribeSolid().

◆ Validate()

G4bool G4LogicalVolumeModel::Validate ( G4bool )
inlinevirtual

Reimplemented from G4VModel.

Definition at line 68 of file G4LogicalVolumeModel.hh.

68{return true;}

Member Data Documentation

◆ fBooleans

G4bool G4LogicalVolumeModel::fBooleans
protected

Definition at line 84 of file G4LogicalVolumeModel.hh.

Referenced by DescribeSolid(), and G4LogicalVolumeModel().

◆ fCheckOverlaps

G4bool G4LogicalVolumeModel::fCheckOverlaps
protected

Definition at line 87 of file G4LogicalVolumeModel.hh.

Referenced by DescribeYourselfTo(), and G4LogicalVolumeModel().

◆ fOverlapsPrinted

G4bool G4LogicalVolumeModel::fOverlapsPrinted
protected

Definition at line 88 of file G4LogicalVolumeModel.hh.

Referenced by DescribeYourselfTo(), and G4LogicalVolumeModel().

◆ 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(), and G4LogicalVolumeModel().

◆ fVoxels

G4bool G4LogicalVolumeModel::fVoxels
protected

Definition at line 85 of file G4LogicalVolumeModel.hh.

Referenced by DescribeYourselfTo(), and G4LogicalVolumeModel().

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