G4ScaledSolid Class Reference

G4ScaledSolid is a solid that has been scaled in dimensions in X, Y or Z, from its original description. More...

#include <G4ScaledSolid.hh>

Inheritance diagram for G4ScaledSolid:

Public Member Functions
	G4ScaledSolid (const G4String &pName, G4VSolid *pSolid, const G4Scale3D &pScale)
	~G4ScaledSolid () override
	G4ScaledSolid (__void__ &)
	G4ScaledSolid (const G4ScaledSolid &rhs)
G4ScaledSolid &	operator= (const G4ScaledSolid &rhs)
EInside	Inside (const G4ThreeVector &p) const override
void	BoundingLimits (G4ThreeVector &pMin, G4ThreeVector &pMax) const override
G4bool	CalculateExtent (const EAxis pAxis, const G4VoxelLimits &pVoxelLimit, const G4AffineTransform &pTransform, G4double &pMin, G4double &pMax) const override
G4ThreeVector	SurfaceNormal (const G4ThreeVector &p) const override
G4double	DistanceToIn (const G4ThreeVector &p, const G4ThreeVector &v) const override
G4double	DistanceToIn (const G4ThreeVector &p) const override
G4double	DistanceToOut (const G4ThreeVector &p, const G4ThreeVector &v, const G4bool calcNorm=false, G4bool *validNorm=nullptr, G4ThreeVector *n=nullptr) const override
G4double	DistanceToOut (const G4ThreeVector &p) const override
void	ComputeDimensions (G4VPVParameterisation *p, const G4int n, const G4VPhysicalVolume *pRep) override
G4double	GetCubicVolume () override
G4double	GetSurfaceArea () override
G4ThreeVector	GetPointOnSurface () const override
G4int	GetNumOfConstituents () const override
G4bool	IsFaceted () const override
G4Scale3D	GetScaleTransform () const
void	SetScaleTransform (const G4Scale3D &scale)
G4VSolid *	GetUnscaledSolid () const
G4GeometryType	GetEntityType () const override
G4VSolid *	Clone () const override
std::ostream &	StreamInfo (std::ostream &os) const override
void	DescribeYourselfTo (G4VGraphicsScene &scene) const override
G4Polyhedron *	CreatePolyhedron () const override
G4Polyhedron *	GetPolyhedron () const override
Public Member Functions inherited from G4VSolid
	G4VSolid (const G4String &name)
virtual	~G4VSolid ()
	G4VSolid (const G4VSolid &rhs)
G4VSolid &	operator= (const G4VSolid &rhs)
G4bool	operator== (const G4VSolid &s) const
G4String	GetName () const
void	SetName (const G4String &name)
G4double	GetTolerance () const
void	DumpInfo () const
virtual G4VisExtent	GetExtent () const
virtual const G4VSolid *	GetConstituentSolid (G4int no) const
virtual G4VSolid *	GetConstituentSolid (G4int no)
virtual const G4DisplacedSolid *	GetDisplacedSolidPtr () const
virtual G4DisplacedSolid *	GetDisplacedSolidPtr ()
	G4VSolid (__void__ &)
G4double	EstimateCubicVolume (G4int nStat, G4double epsilon) const
G4double	EstimateSurfaceArea (G4int nStat, G4double epsilon) const

Additional Inherited Members
Protected Member Functions inherited from G4VSolid
void	CalculateClippedPolygonExtent (G4ThreeVectorList &pPolygon, const G4VoxelLimits &pVoxelLimit, const EAxis pAxis, G4double &pMin, G4double &pMax) const
void	ClipCrossSection (G4ThreeVectorList *pVertices, const G4int pSectionIndex, const G4VoxelLimits &pVoxelLimit, const EAxis pAxis, G4double &pMin, G4double &pMax) const
void	ClipBetweenSections (G4ThreeVectorList *pVertices, const G4int pSectionIndex, const G4VoxelLimits &pVoxelLimit, const EAxis pAxis, G4double &pMin, G4double &pMax) const
void	ClipPolygon (G4ThreeVectorList &pPolygon, const G4VoxelLimits &pVoxelLimit, const EAxis pAxis) const
Protected Attributes inherited from G4VSolid
G4double	kCarTolerance

Detailed Description

G4ScaledSolid is a solid that has been scaled in dimensions in X, Y or Z, from its original description.

Definition at line 50 of file G4ScaledSolid.hh.

Constructor & Destructor Documentation

G4ScaledSolid() [1/3]

G4ScaledSolid::G4ScaledSolid	(	const G4String &	pName,
		G4VSolid *	pSolid,
		const G4Scale3D &	pScale )

Constructor of a solid with scaled transformation.

Parameters

[in]	pName	The name of the solid.
[in]	pSolid	Pointer to the original reference solid.
[in]	pScale	The scaling transformation.

Definition at line 51 of file G4ScaledSolid.cc.

  : G4VSolid(pName), fPtrSolid(pSolid)
{
  fScale = new G4ScaleTransform(pScale);
}

Referenced by Clone(), G4ScaledSolid(), and operator=().

~G4ScaledSolid()

G4ScaledSolid::~G4ScaledSolid ( )

override

The destructor, clearing the cached transformation.

Definition at line 73 of file G4ScaledSolid.cc.

{
  delete fpPolyhedron; fpPolyhedron = nullptr;
  delete fScale; fScale = nullptr;
}

G4ScaledSolid() [2/3]

G4ScaledSolid::G4ScaledSolid

(

__void__ &

a

)

Fake default constructor for usage restricted to direct object persistency for clients requiring preallocation of memory for persistifiable objects.

Definition at line 64 of file G4ScaledSolid.cc.

  : G4VSolid(a)
{
}

G4ScaledSolid() [3/3]

G4ScaledSolid::G4ScaledSolid

(

const G4ScaledSolid &

rhs

)

Copy constructor and assignment operator.

Definition at line 83 of file G4ScaledSolid.cc.

  : G4VSolid (rhs), fPtrSolid(rhs.fPtrSolid),
    fCubicVolume(rhs.fCubicVolume), fSurfaceArea(rhs.fSurfaceArea)
{
  fScale = new G4ScaleTransform(*(rhs.fScale));
}

Member Function Documentation

BoundingLimits()

void G4ScaledSolid::BoundingLimits ( G4ThreeVector & pMin, G4ThreeVector & pMax ) const

overridevirtual

Computes the bounding limits of the solid.

Parameters

[out]	pMin	The minimum bounding limit point.
[out]	pMax	The maximum bounding limit point.

Reimplemented from G4VSolid.

Definition at line 130 of file G4ScaledSolid.cc.

{
  G4ThreeVector bmin,bmax;
  G4ThreeVector scale = fScale->GetScale();
 
  fPtrSolid->BoundingLimits(bmin,bmax);
  pMin.set(bmin.x()*scale.x(),bmin.y()*scale.y(),bmin.z()*scale.z());
  pMax.set(bmax.x()*scale.x(),bmax.y()*scale.y(),bmax.z()*scale.z());
 
  // Check correctness of the bounding box
  //
  if (pMin.x() >= pMax.x() || pMin.y() >= pMax.y() || pMin.z() >= pMax.z())
  {
    std::ostringstream message;
    message << "Bad bounding box (min >= max) for solid: "
            << GetName() << " !"
            << "\npMin = " << pMin
           << "\npMax = " << pMax;
    G4Exception("G4ScaledSolid::BoundingLimits()", "GeomMgt0001",
                JustWarning, message);
    DumpInfo();
  }
}

CalculateExtent()

G4bool G4ScaledSolid::CalculateExtent ( const EAxis pAxis, const G4VoxelLimits & pVoxelLimit, const G4AffineTransform & pTransform, G4double & pMin, G4double & pMax ) const

overridevirtual

Calculates the minimum and maximum extent of the solid, when under the specified transform, and within the specified limits.

Parameters

[in]	pAxis	The axis along which compute the extent.
[in]	pVoxelLimit	The limiting space dictated by voxels.
[in]	pTransform	The internal transformation applied to the solid.
[out]	pMin	The minimum extent value.
[out]	pMax	The maximum extent value.

Returns

True if the solid is intersected by the extent region.

Implements G4VSolid.

Definition at line 160 of file G4ScaledSolid.cc.

{
  // Find bounding box of unscaled solid
  G4ThreeVector bmin,bmax;
  fPtrSolid->BoundingLimits(bmin,bmax);
 
  // Set combined transformation
  G4Transform3D transform3D =
    G4Transform3D(pTransform.NetRotation().inverse(),
                  pTransform.NetTranslation())*GetScaleTransform();
 
  // Find extent
  G4BoundingEnvelope bbox(bmin,bmax);
  return bbox.CalculateExtent(pAxis,pVoxelLimit,transform3D,pMin,pMax);
}

Clone()

G4VSolid * G4ScaledSolid::Clone ( ) const

overridevirtual

Makes a clone of the object for use in multi-treading.

Returns

A pointer to the new cloned allocated solid.

Reimplemented from G4VSolid.

Definition at line 355 of file G4ScaledSolid.cc.

{
  return new G4ScaledSolid(*this);
}

ComputeDimensions()

void G4ScaledSolid::ComputeDimensions ( G4VPVParameterisation * p, const G4int n, const G4VPhysicalVolume * pRep )

overridevirtual

Throws an exception as paramterisations are not allowed for these solids.

Reimplemented from G4VSolid.

Definition at line 305 of file G4ScaledSolid.cc.

{
  DumpInfo();
  G4Exception("G4ScaledSolid::ComputeDimensions()",
              "GeomSolids0001", FatalException,
              "Method not applicable in this context!");
}

CreatePolyhedron()

G4Polyhedron * G4ScaledSolid::CreatePolyhedron ( ) const

overridevirtual

Creates a Polyhedron used for Visualisation. It is the caller's responsibility to delete it. A null pointer means "not created".

Reimplemented from G4VSolid.

Definition at line 454 of file G4ScaledSolid.cc.

{
  G4Polyhedron* polyhedron = fPtrSolid->CreatePolyhedron();
  if (polyhedron != nullptr)
  {
    polyhedron->Transform(GetScaleTransform());
  }
  else
  {
    DumpInfo();
    G4Exception("G4ScaledSolid::CreatePolyhedron()",
                "GeomSolids2003", JustWarning,
                "No G4Polyhedron for scaled solid");
  }
  return polyhedron;
}

Referenced by GetPolyhedron().

DescribeYourselfTo()

void G4ScaledSolid::DescribeYourselfTo ( G4VGraphicsScene & scene ) const

overridevirtual

Methods for creating graphical representations (i.e. for visualisation).

Implements G4VSolid.

Definition at line 444 of file G4ScaledSolid.cc.

{
  scene.AddSolid (*this);
}

DistanceToIn() [1/2]

G4double G4ScaledSolid::DistanceToIn ( const G4ThreeVector & p ) const

overridevirtual

Calculates the safety distance to the nearest surface of a shape from an outside point. The distance can be an underestimate.

Implements G4VSolid.

Definition at line 238 of file G4ScaledSolid.cc.

{
  // Transform point to unscaled shape frame
  G4ThreeVector newPoint;
  fScale->Transform(p, newPoint);
 
  // Compute unscaled safety, then scale it
  G4double dist = fPtrSolid->DistanceToIn(newPoint);
  return fScale->InverseTransformDistance(dist);
}

DistanceToIn() [2/2]

G4double G4ScaledSolid::DistanceToIn ( const G4ThreeVector & p, const G4ThreeVector & v ) const

overridevirtual

Returns the distance along the normalised vector "v" to the shape, from the point at offset "p". If there is no intersection, return kInfinity. The first intersection resulting from leaving a surface/volume is discarded. Hence, it is tolerant of points on the surface of the shape.

Implements G4VSolid.

Definition at line 214 of file G4ScaledSolid.cc.

{
  // Transform point and direction to unscaled shape frame
  G4ThreeVector newPoint;
  fScale->Transform(p, newPoint);
 
  // Direction is un-normalized after scale transformation
  G4ThreeVector newDirection;
  fScale->Transform(v, newDirection);
  newDirection = newDirection/newDirection.mag();
 
  // Compute distance in unscaled system
  G4double dist = fPtrSolid->DistanceToIn(newPoint,newDirection);
 
  // Return converted distance to global
  return fScale->InverseTransformDistance(dist, newDirection);
}

DistanceToOut() [1/2]

G4double G4ScaledSolid::DistanceToOut ( const G4ThreeVector & p ) const

overridevirtual

Calculates the safety distance to the nearest surface of a shape from an inside point "p". The distance can be an underestimate.

Implements G4VSolid.

Definition at line 289 of file G4ScaledSolid.cc.

{
  // Transform point to unscaled shape frame
  G4ThreeVector newPoint;
  fScale->Transform(p, newPoint);
 
  // Compute unscaled safety, then scale it
  G4double dist = fPtrSolid->DistanceToOut(newPoint);
  return fScale->InverseTransformDistance(dist);
}

DistanceToOut() [2/2]

G4double G4ScaledSolid::DistanceToOut ( const G4ThreeVector & p, const G4ThreeVector & v, const G4bool calcNorm = false, G4bool * validNorm = nullptr, G4ThreeVector * n = nullptr ) const

overridevirtual

Returns the distance along the normalised vector "v" to the shape, from a point at an offset "p" inside or on the surface of the shape. Intersections with surfaces, when the point is < Tolerance/2 from a surface must be ignored. Must be called as solid.DistanceToOut(p,v) or by specifying all the parameters.

Parameters

[in]	p	The reference point in space.
[in]	v	The normalised direction.
[in]	calcNorm	Flag to enable the normal computation or not.
[out]	validNorm	Set to true if the solid lies entirely behind or on the exiting surface (calcNorm must be true, otherwise it is unused).
[out]	n	The exiting outwards normal vector (undefined Magnitude). (calcNorm must be true, otherwise it is unused).

Returns

The distance value to exit the volume.

Implements G4VSolid.

Definition at line 254 of file G4ScaledSolid.cc.

{
  // Transform point and direction to unscaled shape frame
  G4ThreeVector newPoint;
  fScale->Transform(p, newPoint);
 
  // Direction is un-normalized after scale transformation
  G4ThreeVector newDirection;
  fScale->Transform(v, newDirection);
  newDirection = newDirection/newDirection.mag();
 
  // Compute distance in unscaled system
  G4ThreeVector solNorm;
  G4double dist = fPtrSolid->DistanceToOut(newPoint,newDirection,
                                           calcNorm,validNorm,&solNorm);
  if(calcNorm)
  {
    G4ThreeVector normal;
    fScale->TransformNormal(solNorm, normal);
    *n = normal.unit();
  }
 
  // Return distance converted to global
  return fScale->InverseTransformDistance(dist, newDirection);
}

GetCubicVolume()

G4double G4ScaledSolid::GetCubicVolume ( )

overridevirtual

Methods returning an estimation of the solid volume (capacity) and surface area, in internal units.

Reimplemented from G4VSolid.

Definition at line 386 of file G4ScaledSolid.cc.

{
  if(fCubicVolume < 0.)
  {
    G4RecursiveAutoLock l(&scaledMutex);
    fCubicVolume = fPtrSolid->GetCubicVolume() *
                   fScale->GetScale().x() *
                   fScale->GetScale().y() *
                   fScale->GetScale().z();
    l.unlock();
  }
  return fCubicVolume;
}

GetEntityType()

G4GeometryType G4ScaledSolid::GetEntityType ( ) const

overridevirtual

Returns the type ID, "G4ScaledSolid" of the solid.

Implements G4VSolid.

Definition at line 346 of file G4ScaledSolid.cc.

{
  return {"G4ScaledSolid"};
}

Referenced by StreamInfo().

GetNumOfConstituents()

G4int G4ScaledSolid::GetNumOfConstituents ( ) const

overridevirtual

Returns the number of constituents of the solid. For non-Boolean solids the return value is one.

Reimplemented from G4VSolid.

Definition at line 328 of file G4ScaledSolid.cc.

{
  return fPtrSolid->GetNumOfConstituents();
}

GetPointOnSurface()

G4ThreeVector G4ScaledSolid::GetPointOnSurface ( ) const

overridevirtual

Returns a random point located on the surface of the solid. Points returned may not necessarily be uniformly distributed.

Reimplemented from G4VSolid.

Definition at line 320 of file G4ScaledSolid.cc.

{
  return fScale->InverseTransform(fPtrSolid->GetPointOnSurface());
}

GetPolyhedron()

G4Polyhedron * G4ScaledSolid::GetPolyhedron ( ) const

overridevirtual

Smart access function - creates on request and stores for future access. A null pointer means "not available".

Reimplemented from G4VSolid.

Definition at line 475 of file G4ScaledSolid.cc.

{
  if (fpPolyhedron == nullptr ||
      fRebuildPolyhedron ||
      fpPolyhedron->GetNumberOfRotationStepsAtTimeOfCreation() !=
      fpPolyhedron->GetNumberOfRotationSteps())
    {
      fpPolyhedron = CreatePolyhedron();
      fRebuildPolyhedron = false;
    }
  return fpPolyhedron;
}

GetScaleTransform()

G4Scale3D G4ScaledSolid::GetScaleTransform

(

)

const

Accessor and setter for the scaling transformation.

Definition at line 364 of file G4ScaledSolid.cc.

{
  return { fScale->GetScale().x(),
           fScale->GetScale().y(),
           fScale->GetScale().z() };
}

Referenced by CalculateExtent(), CreatePolyhedron(), G4tgbGeometryDumper::DumpScaledVolume(), and G4GDMLWriteSolids::ScaledWrite().

GetSurfaceArea()

G4double G4ScaledSolid::GetSurfaceArea ( )

overridevirtual

Returns an estimation of the solid surface area in internal units. This method may be overloaded by derived classes to compute the exact geometrical quantity for solids where this is possible, or anyway to cache the computed value. Note: the computed value is NOT cached.

Reimplemented from G4VSolid.

Definition at line 404 of file G4ScaledSolid.cc.

{
  if(fSurfaceArea < 0.)
  {
    G4RecursiveAutoLock l(&scaledMutex);
    fSurfaceArea = G4VSolid::GetSurfaceArea();
    l.unlock();
  }
  return fSurfaceArea;
}

GetUnscaledSolid()

G4VSolid * G4ScaledSolid::GetUnscaledSolid

(

)

const

Returns a pointer to the original not scaled solid.

Definition at line 121 of file G4ScaledSolid.cc.

{
  return fPtrSolid;
}

Referenced by G4tgbGeometryDumper::DumpScaledVolume(), and G4GDMLWriteSolids::ScaledWrite().

Inside()

EInside G4ScaledSolid::Inside ( const G4ThreeVector & p ) const

overridevirtual

Returns if the given point "p" is inside or not the solid.

Implements G4VSolid.

Definition at line 184 of file G4ScaledSolid.cc.

{
  return fPtrSolid->Inside(fScale->Transform(p));
}

IsFaceted()

G4bool G4ScaledSolid::IsFaceted ( ) const

overridevirtual

Returns true if the solid has only planar faces, false otherwise.

Reimplemented from G4VSolid.

Definition at line 337 of file G4ScaledSolid.cc.

{
  return fPtrSolid->IsFaceted();  
}

operator=()

G4ScaledSolid & G4ScaledSolid::operator=

(

const G4ScaledSolid &

rhs

)

Definition at line 94 of file G4ScaledSolid.cc.

{
  // Check assignment to self
  //
  if (this == &rhs) { return *this; }
 
  // Copy base class data
  //
  G4VSolid::operator=(rhs);
 
  // Copy data
  //
  fPtrSolid = rhs.fPtrSolid;
  delete fScale;
  fScale = new G4ScaleTransform(*(rhs.fScale));
  fCubicVolume = rhs.fCubicVolume;
  fSurfaceArea = rhs.fSurfaceArea;
  fRebuildPolyhedron = false;
  delete fpPolyhedron; fpPolyhedron = nullptr;
 
  return *this;
}

SetScaleTransform()

void G4ScaledSolid::SetScaleTransform

(

const G4Scale3D &

scale

)

Definition at line 375 of file G4ScaledSolid.cc.

{
  delete fScale; 
  fScale = new G4ScaleTransform(scale);
  fRebuildPolyhedron = true;
}

StreamInfo()

std::ostream & G4ScaledSolid::StreamInfo ( std::ostream & os ) const

overridevirtual

Streams the object contents to an output stream.

Implements G4VSolid.

Definition at line 419 of file G4ScaledSolid.cc.

{
  os << "-----------------------------------------------------------\n"
     << "    *** Dump for Scaled solid - " << GetName() << " ***\n"
     << "    ===================================================\n"
     << " Solid type: " << GetEntityType() << "\n"
     << " Parameters of constituent solid: \n"
     << "===========================================================\n";
  fPtrSolid->StreamInfo(os);
  os << "===========================================================\n"
     << " Scaling: \n"
     << "    Scale transformation : \n"
     << "           " << fScale->GetScale().x() << ", "
                      << fScale->GetScale().y() << ", "
                      << fScale->GetScale().z() << "\n"
     << "===========================================================\n";
 
  return os;
}

SurfaceNormal()

G4ThreeVector G4ScaledSolid::SurfaceNormal ( const G4ThreeVector & p ) const

overridevirtual

Returns the outwards pointing unit normal of the shape for the surface closest to the point at offset "p".

Implements G4VSolid.

Definition at line 194 of file G4ScaledSolid.cc.

{
  // Transform point to unscaled shape frame
  G4ThreeVector newPoint;
  fScale->Transform(p, newPoint);
 
  // Compute normal in unscaled frame
  G4ThreeVector newNormal = fPtrSolid->SurfaceNormal(newPoint);
  G4ThreeVector normal;
 
  // Convert normal to scaled frame
  fScale->InverseTransformNormal(newNormal, normal);
  return normal/normal.mag();
}

---

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

• G4ScaledSolid.hh
• G4ScaledSolid.cc