G4ScaledSolid Class Reference

#include <G4ScaledSolid.hh>

Inheritance diagram for G4ScaledSolid:

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

Protected Member Functions
void	CalculateClippedPolygonExtent (G4ThreeVectorList &pPolygon, 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	ClipCrossSection (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
G4double	kCarTolerance

Private Member Functions
void	ClipPolygonToSimpleLimits (G4ThreeVectorList &pPolygon, G4ThreeVectorList &outputPolygon, const G4VoxelLimits &pVoxelLimit) const

Private Attributes
G4double	fCubicVolume = -1.0
G4Polyhedron *	fpPolyhedron = nullptr
G4VSolid *	fPtrSolid = nullptr
G4bool	fRebuildPolyhedron = false
G4ScaleTransform *	fScale = nullptr
G4String	fshapeName
G4double	fSurfaceArea = -1.0

Detailed Description

Definition at line 45 of file G4ScaledSolid.hh.

Constructor & Destructor Documentation

G4ScaledSolid() [1/3]

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

Definition at line 45 of file G4ScaledSolid.cc.

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

References fScale.

Referenced by Clone().

~G4ScaledSolid()

G4ScaledSolid::~G4ScaledSolid ( )

virtual

Definition at line 67 of file G4ScaledSolid.cc.

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

References fpPolyhedron, and fScale.

G4ScaledSolid() [2/3]

G4ScaledSolid::G4ScaledSolid

(

__void__ &

a

)

Definition at line 58 of file G4ScaledSolid.cc.

  : G4VSolid(a)
{
}

G4ScaledSolid() [3/3]

G4ScaledSolid::G4ScaledSolid

(

const G4ScaledSolid &

rhs

)

Definition at line 77 of file G4ScaledSolid.cc.

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

References fScale.

Member Function Documentation

BoundingLimits()

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

virtual

Reimplemented from G4VSolid.

Definition at line 124 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();
  }
}

References G4VSolid::BoundingLimits(), G4VSolid::DumpInfo(), fPtrSolid, fScale, G4Exception(), G4VSolid::GetName(), G4ScaleTransform::GetScale(), JustWarning, pMax, pMin, CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

CalculateClippedPolygonExtent()

void G4VSolid::CalculateClippedPolygonExtent ( G4ThreeVectorList &  pPolygon, const G4VoxelLimits &  pVoxelLimit, const EAxis  pAxis, G4double &  pMin, G4double &  pMax  ) const

protectedinherited

Definition at line 489 of file G4VSolid.cc.

{
  G4int noLeft,i;
  G4double component;
 
  ClipPolygon(pPolygon,pVoxelLimit,pAxis);
  noLeft = pPolygon.size();
 
  if ( noLeft )
  {
    for (i=0; i<noLeft; ++i)
    {
      component = pPolygon[i].operator()(pAxis);
 
      if (component < pMin)
      {
        pMin = component;
      }
      if (component > pMax)
      {
        pMax = component;
      }
    }
  }
}

References G4VSolid::ClipPolygon(), pMax, and pMin.

Referenced by G4VSolid::ClipBetweenSections(), and G4VSolid::ClipCrossSection().

CalculateExtent()

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

virtual

Implements G4VSolid.

Definition at line 154 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);
}

References G4VSolid::BoundingLimits(), G4BoundingEnvelope::CalculateExtent(), fPtrSolid, GetScaleTransform(), CLHEP::HepRotation::inverse(), G4AffineTransform::NetRotation(), G4AffineTransform::NetTranslation(), pMax, and pMin.

CleanTransformations()

void G4ScaledSolid::CleanTransformations

(

)

ClipBetweenSections()

void G4VSolid::ClipBetweenSections ( G4ThreeVectorList *  pVertices, const G4int  pSectionIndex, const G4VoxelLimits &  pVoxelLimit, const EAxis  pAxis, G4double &  pMin, G4double &  pMax  ) const

protectedinherited

Definition at line 444 of file G4VSolid.cc.

{
  G4ThreeVectorList polygon;
  polygon.reserve(4);
  polygon.push_back((*pVertices)[pSectionIndex]);
  polygon.push_back((*pVertices)[pSectionIndex+4]);
  polygon.push_back((*pVertices)[pSectionIndex+5]);
  polygon.push_back((*pVertices)[pSectionIndex+1]);
  CalculateClippedPolygonExtent(polygon,pVoxelLimit,pAxis,pMin,pMax);
  polygon.clear();
 
  polygon.push_back((*pVertices)[pSectionIndex+1]);
  polygon.push_back((*pVertices)[pSectionIndex+5]);
  polygon.push_back((*pVertices)[pSectionIndex+6]);
  polygon.push_back((*pVertices)[pSectionIndex+2]);
  CalculateClippedPolygonExtent(polygon,pVoxelLimit,pAxis,pMin,pMax);
  polygon.clear();
 
  polygon.push_back((*pVertices)[pSectionIndex+2]);
  polygon.push_back((*pVertices)[pSectionIndex+6]);
  polygon.push_back((*pVertices)[pSectionIndex+7]);
  polygon.push_back((*pVertices)[pSectionIndex+3]);
  CalculateClippedPolygonExtent(polygon,pVoxelLimit,pAxis,pMin,pMax);
  polygon.clear();
 
  polygon.push_back((*pVertices)[pSectionIndex+3]);
  polygon.push_back((*pVertices)[pSectionIndex+7]);
  polygon.push_back((*pVertices)[pSectionIndex+4]);
  polygon.push_back((*pVertices)[pSectionIndex]);
  CalculateClippedPolygonExtent(polygon,pVoxelLimit,pAxis,pMin,pMax);
  return;
}

References G4VSolid::CalculateClippedPolygonExtent(), pMax, and pMin.

ClipCrossSection()

void G4VSolid::ClipCrossSection ( G4ThreeVectorList *  pVertices, const G4int  pSectionIndex, const G4VoxelLimits &  pVoxelLimit, const EAxis  pAxis, G4double &  pMin, G4double &  pMax  ) const

protectedinherited

Definition at line 414 of file G4VSolid.cc.

{
 
  G4ThreeVectorList polygon;
  polygon.reserve(4);
  polygon.push_back((*pVertices)[pSectionIndex]);
  polygon.push_back((*pVertices)[pSectionIndex+1]);
  polygon.push_back((*pVertices)[pSectionIndex+2]);
  polygon.push_back((*pVertices)[pSectionIndex+3]);
  CalculateClippedPolygonExtent(polygon,pVoxelLimit,pAxis,pMin,pMax);
  return;
}

References G4VSolid::CalculateClippedPolygonExtent(), pMax, and pMin.

ClipPolygon()

void G4VSolid::ClipPolygon ( G4ThreeVectorList &  pPolygon, const G4VoxelLimits &  pVoxelLimit, const EAxis  pAxis  ) const

protectedinherited

Definition at line 539 of file G4VSolid.cc.

{
  G4ThreeVectorList outputPolygon;
 
  if ( pVoxelLimit.IsLimited() )
  {
    if (pVoxelLimit.IsXLimited() ) // && pAxis != kXAxis)
    {
      G4VoxelLimits simpleLimit1;
      simpleLimit1.AddLimit(kXAxis,pVoxelLimit.GetMinXExtent(),kInfinity);
      ClipPolygonToSimpleLimits(pPolygon,outputPolygon,simpleLimit1);
 
      pPolygon.clear();
 
      if ( !outputPolygon.size() )  return;
 
      G4VoxelLimits simpleLimit2;
      simpleLimit2.AddLimit(kXAxis,-kInfinity,pVoxelLimit.GetMaxXExtent());
      ClipPolygonToSimpleLimits(outputPolygon,pPolygon,simpleLimit2);
 
      if ( !pPolygon.size() )       return;
      else                          outputPolygon.clear();
    }
    if ( pVoxelLimit.IsYLimited() ) // && pAxis != kYAxis)
    {
      G4VoxelLimits simpleLimit1;
      simpleLimit1.AddLimit(kYAxis,pVoxelLimit.GetMinYExtent(),kInfinity);
      ClipPolygonToSimpleLimits(pPolygon,outputPolygon,simpleLimit1);
 
      // Must always clear pPolygon - for clip to simpleLimit2 and in case of
      // early exit
 
      pPolygon.clear();
 
      if ( !outputPolygon.size() )  return;
 
      G4VoxelLimits simpleLimit2;
      simpleLimit2.AddLimit(kYAxis,-kInfinity,pVoxelLimit.GetMaxYExtent());
      ClipPolygonToSimpleLimits(outputPolygon,pPolygon,simpleLimit2);
 
      if ( !pPolygon.size() )       return;
      else                          outputPolygon.clear();
    }
    if ( pVoxelLimit.IsZLimited() ) // && pAxis != kZAxis)
    {
      G4VoxelLimits simpleLimit1;
      simpleLimit1.AddLimit(kZAxis,pVoxelLimit.GetMinZExtent(),kInfinity);
      ClipPolygonToSimpleLimits(pPolygon,outputPolygon,simpleLimit1);
 
      // Must always clear pPolygon - for clip to simpleLimit2 and in case of
      // early exit
 
      pPolygon.clear();
 
      if ( !outputPolygon.size() )  return;
 
      G4VoxelLimits simpleLimit2;
      simpleLimit2.AddLimit(kZAxis,-kInfinity,pVoxelLimit.GetMaxZExtent());
      ClipPolygonToSimpleLimits(outputPolygon,pPolygon,simpleLimit2);
 
      // Return after final clip - no cleanup
    }
  }
}

References G4VoxelLimits::AddLimit(), G4VSolid::ClipPolygonToSimpleLimits(), G4VoxelLimits::GetMaxXExtent(), G4VoxelLimits::GetMaxYExtent(), G4VoxelLimits::GetMaxZExtent(), G4VoxelLimits::GetMinXExtent(), G4VoxelLimits::GetMinYExtent(), G4VoxelLimits::GetMinZExtent(), G4VoxelLimits::IsLimited(), G4VoxelLimits::IsXLimited(), G4VoxelLimits::IsYLimited(), G4VoxelLimits::IsZLimited(), kInfinity, kXAxis, kYAxis, and kZAxis.

Referenced by G4VSolid::CalculateClippedPolygonExtent().

ClipPolygonToSimpleLimits()

void G4VSolid::ClipPolygonToSimpleLimits ( G4ThreeVectorList &  pPolygon, G4ThreeVectorList &  outputPolygon, const G4VoxelLimits &  pVoxelLimit  ) const

privateinherited

Definition at line 612 of file G4VSolid.cc.

{
  G4int i;
  G4int noVertices=pPolygon.size();
  G4ThreeVector vEnd,vStart;
 
  for (i = 0 ; i < noVertices ; ++i )
  {
    vStart = pPolygon[i];
    if ( i == noVertices-1 )    vEnd = pPolygon[0];
    else                        vEnd = pPolygon[i+1];
 
    if ( pVoxelLimit.Inside(vStart) )
    {
      if (pVoxelLimit.Inside(vEnd))
      {
        // vStart and vEnd inside -> output end point
        //
        outputPolygon.push_back(vEnd);
      }
      else
      {
        // vStart inside, vEnd outside -> output crossing point
        //
        pVoxelLimit.ClipToLimits(vStart,vEnd);
        outputPolygon.push_back(vEnd);
      }
    }
    else
    {
      if (pVoxelLimit.Inside(vEnd))
      {
        // vStart outside, vEnd inside -> output inside section
        //
        pVoxelLimit.ClipToLimits(vStart,vEnd);
        outputPolygon.push_back(vStart);
        outputPolygon.push_back(vEnd);
      }
      else  // Both point outside -> no output
      {
        // outputPolygon.push_back(vStart);
        // outputPolygon.push_back(vEnd);
      }
    }
  }
}

References G4VoxelLimits::ClipToLimits(), and G4VoxelLimits::Inside().

Referenced by G4VSolid::ClipPolygon().

Clone()

G4VSolid * G4ScaledSolid::Clone ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 332 of file G4ScaledSolid.cc.

{
  return new G4ScaledSolid(*this);
}

References G4ScaledSolid().

ComputeDimensions()

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

virtual

Reimplemented from G4VSolid.

Definition at line 299 of file G4ScaledSolid.cc.

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

References G4VSolid::DumpInfo(), FatalException, and G4Exception().

CreatePolyhedron()

G4Polyhedron * G4ScaledSolid::CreatePolyhedron ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 427 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;
}

References G4VSolid::CreatePolyhedron(), G4VSolid::DumpInfo(), fPtrSolid, G4Exception(), GetScaleTransform(), JustWarning, and HepPolyhedron::Transform().

Referenced by GetPolyhedron().

DescribeYourselfTo()

void G4ScaledSolid::DescribeYourselfTo ( G4VGraphicsScene &  scene ) const

virtual

Implements G4VSolid.

Definition at line 417 of file G4ScaledSolid.cc.

{
  scene.AddSolid (*this);
}

References G4VGraphicsScene::AddSolid().

DistanceToIn() [1/2]

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

virtual

Implements G4VSolid.

Definition at line 232 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);
}

References G4VSolid::DistanceToIn(), fPtrSolid, fScale, G4ScaleTransform::InverseTransformDistance(), and G4ScaleTransform::Transform().

DistanceToIn() [2/2]

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

virtual

Implements G4VSolid.

Definition at line 208 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);
}

References G4VSolid::DistanceToIn(), fPtrSolid, fScale, G4ScaleTransform::InverseTransformDistance(), CLHEP::Hep3Vector::mag(), and G4ScaleTransform::Transform().

DistanceToOut() [1/2]

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

virtual

Implements G4VSolid.

Definition at line 283 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);
}

References G4VSolid::DistanceToOut(), fPtrSolid, fScale, G4ScaleTransform::InverseTransformDistance(), and G4ScaleTransform::Transform().

DistanceToOut() [2/2]

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

virtual

Implements G4VSolid.

Definition at line 248 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);
}

References G4VSolid::DistanceToOut(), fPtrSolid, fScale, G4ScaleTransform::InverseTransformDistance(), CLHEP::Hep3Vector::mag(), CLHEP::detail::n, CLHEP::normal(), G4ScaleTransform::Transform(), and G4ScaleTransform::TransformNormal().

DumpInfo()

void G4VSolid::DumpInfo ( ) const

inlineinherited

Referenced by G4Cons::ApproxSurfaceNormal(), G4CutTubs::ApproxSurfaceNormal(), G4Sphere::ApproxSurfaceNormal(), G4Torus::ApproxSurfaceNormal(), G4Tubs::ApproxSurfaceNormal(), G4ReflectedSolid::BoundingLimits(), G4DisplacedSolid::BoundingLimits(), G4IntersectionSolid::BoundingLimits(), BoundingLimits(), G4SubtractionSolid::BoundingLimits(), G4UnionSolid::BoundingLimits(), G4Box::BoundingLimits(), G4Cons::BoundingLimits(), G4CutTubs::BoundingLimits(), G4Orb::BoundingLimits(), G4Para::BoundingLimits(), G4Sphere::BoundingLimits(), G4Torus::BoundingLimits(), G4Trap::BoundingLimits(), G4Trd::BoundingLimits(), G4Tubs::BoundingLimits(), G4EllipticalCone::BoundingLimits(), G4ExtrudedSolid::BoundingLimits(), G4GenericPolycone::BoundingLimits(), G4GenericTrap::BoundingLimits(), G4Hype::BoundingLimits(), G4Paraboloid::BoundingLimits(), G4Polycone::BoundingLimits(), G4Polyhedra::BoundingLimits(), G4TessellatedSolid::BoundingLimits(), G4TwistedTubs::BoundingLimits(), G4ParameterisationBoxX::ComputeDimensions(), G4ParameterisationBoxY::ComputeDimensions(), G4ParameterisationBoxZ::ComputeDimensions(), G4ParameterisationConsRho::ComputeDimensions(), G4ParameterisationConsPhi::ComputeDimensions(), G4ParameterisationConsZ::ComputeDimensions(), G4ParameterisationParaX::ComputeDimensions(), G4ParameterisationParaY::ComputeDimensions(), G4ParameterisationParaZ::ComputeDimensions(), G4ParameterisationPolyconeRho::ComputeDimensions(), G4ParameterisationPolyconePhi::ComputeDimensions(), G4ParameterisationPolyconeZ::ComputeDimensions(), G4ParameterisationPolyhedraRho::ComputeDimensions(), G4ParameterisationPolyhedraPhi::ComputeDimensions(), G4ParameterisationPolyhedraZ::ComputeDimensions(), G4ParameterisationTrdX::ComputeDimensions(), G4ParameterisationTrdY::ComputeDimensions(), G4ParameterisationTrdZ::ComputeDimensions(), G4ParameterisationTubsRho::ComputeDimensions(), G4ParameterisationTubsPhi::ComputeDimensions(), G4ParameterisationTubsZ::ComputeDimensions(), G4ReflectedSolid::ComputeDimensions(), G4DisplacedSolid::ComputeDimensions(), ComputeDimensions(), G4ParameterisedNavigation::ComputeStep(), G4ReplicaNavigation::ComputeStep(), G4DisplacedSolid::CreatePolyhedron(), CreatePolyhedron(), G4SubtractionSolid::DistanceToIn(), G4Box::DistanceToOut(), G4Orb::DistanceToOut(), G4Para::DistanceToOut(), G4Trap::DistanceToOut(), G4Trd::DistanceToOut(), G4Paraboloid::DistanceToOut(), G4VTwistedFaceted::DistanceToOut(), G4Cons::DistanceToOut(), G4CutTubs::DistanceToOut(), G4Sphere::DistanceToOut(), G4Torus::DistanceToOut(), G4Tubs::DistanceToOut(), G4Ellipsoid::DistanceToOut(), G4EllipticalCone::DistanceToOut(), G4EllipticalTube::DistanceToOut(), G4GenericTrap::DistanceToOut(), export_G4VSolid(), G4Polycone::G4Polycone(), G4Polyhedra::G4Polyhedra(), G4BooleanSolid::GetConstituentSolid(), G4NavigationLogger::PostComputeStepLog(), G4Box::SurfaceNormal(), G4Para::SurfaceNormal(), G4Trap::SurfaceNormal(), G4Trd::SurfaceNormal(), G4Ellipsoid::SurfaceNormal(), G4EllipticalCone::SurfaceNormal(), G4EllipticalTube::SurfaceNormal(), G4ExtrudedSolid::SurfaceNormal(), and G4Tet::SurfaceNormal().

EstimateCubicVolume()

G4double G4VSolid::EstimateCubicVolume ( G4int  nStat, G4double  epsilon  ) const

inherited

Definition at line 203 of file G4VSolid.cc.

{
  G4int iInside=0;
  G4double px,py,pz,minX,maxX,minY,maxY,minZ,maxZ,volume,halfepsilon;
  G4ThreeVector p;
  EInside in;
 
  // values needed for CalculateExtent signature
 
  G4VoxelLimits limit;                // Unlimited
  G4AffineTransform origin;
 
  // min max extents of pSolid along X,Y,Z
 
  CalculateExtent(kXAxis,limit,origin,minX,maxX);
  CalculateExtent(kYAxis,limit,origin,minY,maxY);
  CalculateExtent(kZAxis,limit,origin,minZ,maxZ);
 
  // limits
 
  if(nStat < 100)    nStat   = 100;
  if(epsilon > 0.01) epsilon = 0.01;
  halfepsilon = 0.5*epsilon;
 
  for(auto i = 0; i < nStat; ++i )
  {
    px = minX-halfepsilon+(maxX-minX+epsilon)*G4QuickRand();
    py = minY-halfepsilon+(maxY-minY+epsilon)*G4QuickRand();
    pz = minZ-halfepsilon+(maxZ-minZ+epsilon)*G4QuickRand();
    p  = G4ThreeVector(px,py,pz);
    in = Inside(p);
    if(in != kOutside) ++iInside;
  }
  volume = (maxX-minX+epsilon)*(maxY-minY+epsilon)
         * (maxZ-minZ+epsilon)*iInside/nStat;
  return volume;
}

References G4VSolid::CalculateExtent(), epsilon(), G4QuickRand(), G4VSolid::Inside(), kOutside, kXAxis, kYAxis, kZAxis, and maxZ.

Referenced by G4VSolid::GetCubicVolume(), G4BooleanSolid::GetCubicVolume(), and G4VCSGfaceted::GetCubicVolume().

EstimateSurfaceArea()

G4double G4VSolid::EstimateSurfaceArea ( G4int  nStat, G4double  ell  ) const

inherited

Definition at line 265 of file G4VSolid.cc.

{
  static const G4double s2 = 1./std::sqrt(2.);
  static const G4double s3 = 1./std::sqrt(3.);
  static const G4ThreeVector directions[64] =
  {
    G4ThreeVector(  0,  0,  0), G4ThreeVector( -1,  0,  0), // (  ,  ,  ) ( -,  ,  )
    G4ThreeVector(  1,  0,  0), G4ThreeVector( -1,  0,  0), // ( +,  ,  ) (-+,  ,  )
    G4ThreeVector(  0, -1,  0), G4ThreeVector(-s2,-s2,  0), // (  , -,  ) ( -, -,  )
    G4ThreeVector( s2, -s2, 0), G4ThreeVector(  0, -1,  0), // ( +, -,  ) (-+, -,  )
 
    G4ThreeVector(  0,  1,  0), G4ThreeVector( -s2, s2, 0), // (  , +,  ) ( -, +,  )
    G4ThreeVector( s2, s2,  0), G4ThreeVector(  0,  1,  0), // ( +, +,  ) (-+, +,  )
    G4ThreeVector(  0, -1,  0), G4ThreeVector( -1,  0,  0), // (  ,-+,  ) ( -,-+,  )
    G4ThreeVector(  1,  0,  0), G4ThreeVector( -1,  0,  0), // ( +,-+,  ) (-+,-+,  )
 
    G4ThreeVector(  0,  0, -1), G4ThreeVector(-s2,  0,-s2), // (  ,  , -) ( -,  , -)
    G4ThreeVector( s2,  0,-s2), G4ThreeVector(  0,  0, -1), // ( +,  , -) (-+,  , -)
    G4ThreeVector(  0,-s2,-s2), G4ThreeVector(-s3,-s3,-s3), // (  , -, -) ( -, -, -)
    G4ThreeVector( s3,-s3,-s3), G4ThreeVector(  0,-s2,-s2), // ( +, -, -) (-+, -, -)
 
    G4ThreeVector(  0, s2,-s2), G4ThreeVector(-s3, s3,-s3), // (  , +, -) ( -, +, -)
    G4ThreeVector( s3, s3,-s3), G4ThreeVector(  0, s2,-s2), // ( +, +, -) (-+, +, -)
    G4ThreeVector(  0,  0, -1), G4ThreeVector(-s2,  0,-s2), // (  ,-+, -) ( -,-+, -)
    G4ThreeVector( s2,  0,-s2), G4ThreeVector(  0,  0, -1), // ( +,-+, -) (-+,-+, -)
 
    G4ThreeVector(  0,  0,  1), G4ThreeVector(-s2,  0, s2), // (  ,  , +) ( -,  , +)
    G4ThreeVector( s2,  0, s2), G4ThreeVector(  0,  0,  1), // ( +,  , +) (-+,  , +)
    G4ThreeVector(  0,-s2, s2), G4ThreeVector(-s3,-s3, s3), // (  , -, +) ( -, -, +)
    G4ThreeVector( s3,-s3, s3), G4ThreeVector(  0,-s2, s2), // ( +, -, +) (-+, -, +)
 
    G4ThreeVector(  0, s2, s2), G4ThreeVector(-s3, s3, s3), // (  , +, +) ( -, +, +)
    G4ThreeVector( s3, s3, s3), G4ThreeVector(  0, s2, s2), // ( +, +, +) (-+, +, +)
    G4ThreeVector(  0,  0,  1), G4ThreeVector(-s2,  0, s2), // (  ,-+, +) ( -,-+, +)
    G4ThreeVector( s2,  0, s2), G4ThreeVector(  0,  0,  1), // ( +,-+, +) (-+,-+, +)
 
    G4ThreeVector(  0,  0, -1), G4ThreeVector( -1,  0,  0), // (  ,  ,-+) ( -,  ,-+)
    G4ThreeVector(  1,  0,  0), G4ThreeVector( -1,  0,  0), // ( +,  ,-+) (-+,  ,-+)
    G4ThreeVector(  0, -1,  0), G4ThreeVector(-s2,-s2,  0), // (  , -,-+) ( -, -,-+)
    G4ThreeVector( s2, -s2, 0), G4ThreeVector(  0, -1,  0), // ( +, -,-+) (-+, -,-+)
 
    G4ThreeVector(  0,  1,  0), G4ThreeVector( -s2, s2, 0), // (  , +,-+) ( -, +,-+)
    G4ThreeVector( s2, s2,  0), G4ThreeVector(  0,  1,  0), // ( +, +,-+) (-+, +,-+)
    G4ThreeVector(  0, -1,  0), G4ThreeVector( -1,  0,  0), // (  ,-+,-+) ( -,-+,-+)
    G4ThreeVector(  1,  0,  0), G4ThreeVector( -1,  0,  0), // ( +,-+,-+) (-+,-+,-+)
  };
 
  G4ThreeVector bmin, bmax;
  BoundingLimits(bmin, bmax);
 
  G4double dX = bmax.x() - bmin.x();
  G4double dY = bmax.y() - bmin.y();
  G4double dZ = bmax.z() - bmin.z();
 
  // Define statistics and shell thickness
  //
  G4int npoints = (nstat < 1000) ? 1000 : nstat;
  G4double coeff = 0.5 / std::cbrt(G4double(npoints));
  G4double eps = (ell > 0) ? ell : coeff * std::min(std::min(dX, dY), dZ);
  G4double del = 1.8 * eps; // shold be more than sqrt(3.)
 
  G4double minX = bmin.x() - eps;
  G4double minY = bmin.y() - eps;
  G4double minZ = bmin.z() - eps;
 
  G4double dd = 2. * eps;
  dX += dd;
  dY += dd;
  dZ += dd;
 
  // Calculate surface area
  //
  G4int icount = 0;
  for(auto i = 0; i < npoints; ++i)
  {
    G4double px = minX + dX*G4QuickRand();
    G4double py = minY + dY*G4QuickRand();
    G4double pz = minZ + dZ*G4QuickRand();
    G4ThreeVector p  = G4ThreeVector(px, py, pz);
    EInside in = Inside(p);
    G4double dist = 0;
    if (in == kInside)
    {
      if (DistanceToOut(p) >= eps) continue;
      G4int icase = 0;
      if (Inside(G4ThreeVector(px-del, py, pz)) != kInside) icase += 1;
      if (Inside(G4ThreeVector(px+del, py, pz)) != kInside) icase += 2;
      if (Inside(G4ThreeVector(px, py-del, pz)) != kInside) icase += 4;
      if (Inside(G4ThreeVector(px, py+del, pz)) != kInside) icase += 8;
      if (Inside(G4ThreeVector(px, py, pz-del)) != kInside) icase += 16;
      if (Inside(G4ThreeVector(px, py, pz+del)) != kInside) icase += 32;
      if (icase == 0) continue;
      G4ThreeVector v = directions[icase];
      dist = DistanceToOut(p, v);
      G4ThreeVector n = SurfaceNormal(p + v*dist);
      dist *= v.dot(n);
    }
    else if (in == kOutside)
    {
      if (DistanceToIn(p) >= eps) continue;
      G4int icase = 0;
      if (Inside(G4ThreeVector(px-del, py, pz)) != kOutside) icase += 1;
      if (Inside(G4ThreeVector(px+del, py, pz)) != kOutside) icase += 2;
      if (Inside(G4ThreeVector(px, py-del, pz)) != kOutside) icase += 4;
      if (Inside(G4ThreeVector(px, py+del, pz)) != kOutside) icase += 8;
      if (Inside(G4ThreeVector(px, py, pz-del)) != kOutside) icase += 16;
      if (Inside(G4ThreeVector(px, py, pz+del)) != kOutside) icase += 32;
      if (icase == 0) continue;
      G4ThreeVector v = directions[icase];
      dist = DistanceToIn(p, v);
      if (dist == kInfinity) continue;
      G4ThreeVector n = SurfaceNormal(p + v*dist);
      dist *= -(v.dot(n));
    }
    if (dist < eps) ++icount;
  }
  return dX*dY*dZ*icount/npoints/dd;
}

References G4VSolid::BoundingLimits(), G4VSolid::DistanceToIn(), G4VSolid::DistanceToOut(), CLHEP::Hep3Vector::dot(), eps, G4QuickRand(), G4VSolid::Inside(), kInfinity, kInside, kOutside, G4INCL::Math::min(), CLHEP::detail::n, G4VSolid::SurfaceNormal(), CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

Referenced by G4VSolid::GetSurfaceArea(), G4MultiUnion::GetSurfaceArea(), and G4VCSGfaceted::GetSurfaceArea().

GetConstituentSolid() [1/2]

G4VSolid * G4VSolid::GetConstituentSolid ( G4int  no )

virtualinherited

Reimplemented in G4BooleanSolid.

Definition at line 170 of file G4VSolid.cc.

{ return nullptr; }

GetConstituentSolid() [2/2]

const G4VSolid * G4VSolid::GetConstituentSolid ( G4int  no ) const

virtualinherited

Reimplemented in G4BooleanSolid.

Definition at line 167 of file G4VSolid.cc.

{ return nullptr; }

Referenced by G4BooleanSolid::StackPolyhedron().

GetCubicVolume()

G4double G4ScaledSolid::GetCubicVolume ( )

virtual

Reimplemented from G4VSolid.

Definition at line 363 of file G4ScaledSolid.cc.

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

References fCubicVolume, fPtrSolid, fScale, G4VSolid::GetCubicVolume(), G4ScaleTransform::GetScale(), CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

GetDisplacedSolidPtr() [1/2]

G4DisplacedSolid * G4VSolid::GetDisplacedSolidPtr ( )

virtualinherited

Reimplemented in G4DisplacedSolid.

Definition at line 176 of file G4VSolid.cc.

{ return nullptr; }

GetDisplacedSolidPtr() [2/2]

const G4DisplacedSolid * G4VSolid::GetDisplacedSolidPtr ( ) const

virtualinherited

Reimplemented in G4DisplacedSolid.

Definition at line 173 of file G4VSolid.cc.

{ return nullptr; }

GetEntityType()

G4GeometryType G4ScaledSolid::GetEntityType ( ) const

virtual

Implements G4VSolid.

Definition at line 323 of file G4ScaledSolid.cc.

{
  return G4String("G4ScaledSolid");
}

Referenced by StreamInfo().

GetExtent()

G4VisExtent G4VSolid::GetExtent ( ) const

virtualinherited

Reimplemented in G4Box, G4Orb, G4Sphere, G4Ellipsoid, G4EllipticalCone, G4EllipticalTube, G4GenericTrap, G4Hype, G4TessellatedSolid, G4Tet, G4TwistedTubs, G4VCSGfaceted, and G4VTwistedFaceted.

Definition at line 682 of file G4VSolid.cc.

{
  G4VisExtent extent;
  G4VoxelLimits voxelLimits;  // Defaults to "infinite" limits.
  G4AffineTransform affineTransform;
  G4double vmin, vmax;
  CalculateExtent(kXAxis,voxelLimits,affineTransform,vmin,vmax);
  extent.SetXmin (vmin);
  extent.SetXmax (vmax);
  CalculateExtent(kYAxis,voxelLimits,affineTransform,vmin,vmax);
  extent.SetYmin (vmin);
  extent.SetYmax (vmax);
  CalculateExtent(kZAxis,voxelLimits,affineTransform,vmin,vmax);
  extent.SetZmin (vmin);
  extent.SetZmax (vmax);
  return extent;
}

References G4VSolid::CalculateExtent(), kXAxis, kYAxis, kZAxis, G4VisExtent::SetXmax(), G4VisExtent::SetXmin(), G4VisExtent::SetYmax(), G4VisExtent::SetYmin(), G4VisExtent::SetZmax(), and G4VisExtent::SetZmin().

Referenced by G4tgbVolume::BuildSolidForDivision(), G4BoundingExtentScene::ProcessVolume(), G4BoundingSphereScene::ProcessVolume(), and G4VisCommandsTouchable::SetNewValue().

GetName()

G4String G4VSolid::GetName ( ) const

inlineinherited

Referenced by G4GMocrenFileSceneHandler::AddDetector(), G4HepRepFileSceneHandler::AddHepRepInstance(), G4GMocrenFileSceneHandler::AddPrimitive(), G4HepRepFileSceneHandler::AddSolid(), G4GMocrenFileSceneHandler::AddSolid(), G4VtkSceneHandler::AddSolid(), G4GDMLWriteSolids::AddSolid(), G4NavigationLogger::AlongComputeStepLog(), G4GDMLWriteSolids::BooleanWrite(), G4ReflectedSolid::BoundingLimits(), G4DisplacedSolid::BoundingLimits(), G4IntersectionSolid::BoundingLimits(), BoundingLimits(), G4SubtractionSolid::BoundingLimits(), G4UnionSolid::BoundingLimits(), G4Box::BoundingLimits(), G4Cons::BoundingLimits(), G4CutTubs::BoundingLimits(), G4Orb::BoundingLimits(), G4Para::BoundingLimits(), G4Sphere::BoundingLimits(), G4Torus::BoundingLimits(), G4Trap::BoundingLimits(), G4Trd::BoundingLimits(), G4Tubs::BoundingLimits(), G4EllipticalCone::BoundingLimits(), G4ExtrudedSolid::BoundingLimits(), G4GenericPolycone::BoundingLimits(), G4GenericTrap::BoundingLimits(), G4Hype::BoundingLimits(), G4Paraboloid::BoundingLimits(), G4Polycone::BoundingLimits(), G4Polyhedra::BoundingLimits(), G4TessellatedSolid::BoundingLimits(), G4TwistedTubs::BoundingLimits(), G4GDMLWriteSolids::BoxWrite(), G4ExtrudedSolid::CalculateExtent(), G4GenericPolycone::CalculateExtent(), G4Polycone::CalculateExtent(), G4Polyhedra::CalculateExtent(), G4NavigationLogger::CheckDaughterEntryPoint(), G4VDivisionParameterisation::CheckNDivAndWidth(), G4VDivisionParameterisation::CheckOffset(), G4GenericTrap::CheckOrder(), G4Para::CheckParameters(), G4Trap::CheckParameters(), G4Trd::CheckParameters(), G4Ellipsoid::CheckParameters(), G4EllipticalTube::CheckParameters(), G4ParameterisationPolyconeRho::CheckParametersValidity(), G4ParameterisationPolyconeZ::CheckParametersValidity(), G4ParameterisationPolyhedraRho::CheckParametersValidity(), G4ParameterisationPolyhedraPhi::CheckParametersValidity(), G4ParameterisationPolyhedraZ::CheckParametersValidity(), G4PhantomParameterisation::CheckVoxelsFillContainer(), G4GenericTrap::ComputeIsTwisted(), G4VoxelNavigation::ComputeSafety(), G4VoxelSafety::ComputeSafety(), G4NavigationLogger::ComputeSafetyLog(), G4ParameterisedNavigation::ComputeStep(), G4ReplicaNavigation::ComputeStep(), G4GDMLWriteSolids::ConeWrite(), G4Polyhedra::Create(), G4GenericPolycone::Create(), G4Polycone::Create(), G4PhysicalVolumeModel::CreateCurrentAttValues(), G4ReflectedSolid::CreatePolyhedron(), G4ReflectionFactory::CreateReflectedLV(), G4GenericTrap::CreateTessellatedSolid(), G4GDMLWriteSolids::CutTubeWrite(), G4SolidStore::DeRegister(), G4PhysicalVolumeModel::DescribeSolid(), G4SubtractionSolid::DistanceToIn(), G4Paraboloid::DistanceToIn(), G4TessellatedSolid::DistanceToIn(), G4Box::DistanceToOut(), G4Orb::DistanceToOut(), G4Para::DistanceToOut(), G4Trap::DistanceToOut(), G4Trd::DistanceToOut(), G4EllipticalCone::DistanceToOut(), G4TessellatedSolid::DistanceToOut(), G4Ellipsoid::DistanceToOut(), G4EllipticalTube::DistanceToOut(), G4tgbGeometryDumper::DumpMultiUnionVolume(), G4tgbGeometryDumper::DumpScaledVolume(), G4tgbGeometryDumper::DumpSolid(), G4GDMLWriteSolids::ElconeWrite(), G4GDMLWriteSolids::EllipsoidWrite(), G4GDMLWriteSolids::EltubeWrite(), G4PVDivision::ErrorInAxis(), G4ReplicatedSlice::ErrorInAxis(), export_G4VSolid(), G4Box::G4Box(), G4Cons::G4Cons(), G4CutTubs::G4CutTubs(), G4EllipticalCone::G4EllipticalCone(), G4Hype::G4Hype(), G4Para::G4Para(), G4Paraboloid::G4Paraboloid(), G4Polycone::G4Polycone(), G4Polyhedra::G4Polyhedra(), G4Sphere::G4Sphere(), G4Tet::G4Tet(), G4Trap::G4Trap(), G4Tubs::G4Tubs(), G4VParameterisationCons::G4VParameterisationCons(), G4VParameterisationPara::G4VParameterisationPara(), G4VParameterisationPolycone::G4VParameterisationPolycone(), G4VParameterisationPolyhedra::G4VParameterisationPolyhedra(), G4VParameterisationTrd::G4VParameterisationTrd(), G4VTwistedFaceted::G4VTwistedFaceted(), G4GDMLWriteSolids::GenericPolyconeWrite(), G4GDMLWriteSolids::GenTrapWrite(), G4Navigator::GetGlobalExitNormal(), G4Navigator::GetLocalExitNormal(), G4ITNavigator1::GetLocalExitNormal(), G4ITNavigator2::GetLocalExitNormal(), G4BooleanSolid::GetPointOnSurface(), G4PhantomParameterisation::GetReplicaNo(), G4GDMLWriteSolids::HypeWrite(), G4TessellatedSolid::InsideNoVoxels(), G4TessellatedSolid::InsideVoxels(), G4ITNavigator1::LocateGlobalPointAndSetup(), G4ITNavigator2::LocateGlobalPointAndSetup(), G4Navigator::LocateGlobalPointAndSetup(), G4GenericTrap::MakeDownFacet(), G4Trap::MakePlanes(), G4GenericTrap::MakeUpFacet(), G4GDMLWriteSolids::MultiUnionWrite(), G4GDMLWriteSolids::OrbWrite(), G4GDMLWriteSolids::ParaboloidWrite(), G4GDMLWriteParamvol::ParametersWrite(), G4GDMLWriteSolids::ParaWrite(), G4GDMLWriteSolids::PolyconeWrite(), G4GDMLWriteSolids::PolyhedraWrite(), G4NavigationLogger::PostComputeStepLog(), G4NavigationLogger::PreComputeStepLog(), G4NavigationLogger::PrintDaughterLog(), G4PseudoScene::ProcessVolume(), G4SolidStore::Register(), G4tgbVolumeMgr::RegisterMe(), G4NavigationLogger::ReportOutsideMother(), G4ASCIITreeSceneHandler::RequestPrimitives(), G4VSceneHandler::RequestPrimitives(), G4GenericPolycone::Reset(), G4Polyhedra::Reset(), G4VoxelSafety::SafetyForVoxelNode(), G4GDMLWriteSolids::ScaledWrite(), G4Torus::SetAllParameters(), G4Tet::SetBoundingLimits(), G4Polycone::SetOriginalParameters(), G4Polyhedra::SetOriginalParameters(), G4TessellatedSolid::SetSolidClosed(), G4Tet::SetVertices(), G4Box::SetXHalfLength(), G4Box::SetYHalfLength(), G4Box::SetZHalfLength(), G4GDMLWriteSolids::SphereWrite(), G4BooleanSolid::StackPolyhedron(), G4ReflectedSolid::StreamInfo(), G4BooleanSolid::StreamInfo(), G4DisplacedSolid::StreamInfo(), G4MultiUnion::StreamInfo(), StreamInfo(), G4Box::StreamInfo(), G4Cons::StreamInfo(), G4CSGSolid::StreamInfo(), G4CutTubs::StreamInfo(), G4Orb::StreamInfo(), G4Para::StreamInfo(), G4Sphere::StreamInfo(), G4Torus::StreamInfo(), G4Trap::StreamInfo(), G4Trd::StreamInfo(), G4Tubs::StreamInfo(), G4Ellipsoid::StreamInfo(), G4EllipticalCone::StreamInfo(), G4EllipticalTube::StreamInfo(), G4ExtrudedSolid::StreamInfo(), G4GenericPolycone::StreamInfo(), G4GenericTrap::StreamInfo(), G4Hype::StreamInfo(), G4Paraboloid::StreamInfo(), G4Polycone::StreamInfo(), G4Polyhedra::StreamInfo(), G4TessellatedSolid::StreamInfo(), G4Tet::StreamInfo(), G4TwistedBox::StreamInfo(), G4TwistedTrap::StreamInfo(), G4TwistedTrd::StreamInfo(), G4TwistedTubs::StreamInfo(), G4VCSGfaceted::StreamInfo(), G4VTwistedFaceted::StreamInfo(), G4GDMLRead::StripNames(), SubstractSolids(), G4UnionSolid::SurfaceNormal(), G4Box::SurfaceNormal(), G4Para::SurfaceNormal(), G4Trap::SurfaceNormal(), G4Trd::SurfaceNormal(), G4Ellipsoid::SurfaceNormal(), G4EllipticalCone::SurfaceNormal(), G4EllipticalTube::SurfaceNormal(), G4ExtrudedSolid::SurfaceNormal(), G4Tet::SurfaceNormal(), G4GDMLWriteSolids::TessellatedWrite(), G4GDMLWriteSolids::TetWrite(), G4GDMLWriteSolids::TorusWrite(), G4GDMLWriteSolids::TrapWrite(), G4GDMLWriteStructure::TraverseVolumeTree(), G4GDMLWriteSolids::TrdWrite(), G4GDMLWriteSolids::TubeWrite(), G4GDMLWriteSolids::TwistedboxWrite(), G4GDMLWriteSolids::TwistedtrapWrite(), G4GDMLWriteSolids::TwistedtrdWrite(), G4GDMLWriteSolids::TwistedtubsWrite(), G4PhysicalVolumeModel::VisitGeometryAndGetVisReps(), and G4GDMLWriteSolids::XtruWrite().

GetPointOnSurface()

G4ThreeVector G4ScaledSolid::GetPointOnSurface ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 314 of file G4ScaledSolid.cc.

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

References fPtrSolid, fScale, G4VSolid::GetPointOnSurface(), and G4ScaleTransform::InverseTransform().

GetPolyhedron()

G4Polyhedron * G4ScaledSolid::GetPolyhedron ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 448 of file G4ScaledSolid.cc.

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

References CreatePolyhedron(), fpPolyhedron, fRebuildPolyhedron, HepPolyhedron::GetNumberOfRotationSteps(), and G4Polyhedron::GetNumberOfRotationStepsAtTimeOfCreation().

GetScaleTransform()

G4Scale3D G4ScaledSolid::GetScaleTransform

(

)

const

Definition at line 341 of file G4ScaledSolid.cc.

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

References fScale, G4ScaleTransform::GetScale(), CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

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

GetSurfaceArea()

G4double G4ScaledSolid::GetSurfaceArea ( )

virtual

Reimplemented from G4VSolid.

Definition at line 379 of file G4ScaledSolid.cc.

{
  if(fSurfaceArea < 0.)
  {
    fSurfaceArea = G4VSolid::GetSurfaceArea();
  }
  return fSurfaceArea;
}

References fSurfaceArea, and G4VSolid::GetSurfaceArea().

GetTolerance()

G4double G4VSolid::GetTolerance ( ) const

inlineinherited

Referenced by G4NavigationLogger::CheckDaughterEntryPoint(), G4ParameterisedNavigation::ComputeStep(), G4NavigationLogger::PreComputeStepLog(), G4NavigationLogger::ReportOutsideMother(), and G4NavigationLogger::ReportVolumeAndIntersection().

GetUnscaledSolid()

G4VSolid * G4ScaledSolid::GetUnscaledSolid

(

)

const

Definition at line 115 of file G4ScaledSolid.cc.

{
  return fPtrSolid;
}

References fPtrSolid.

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

Inside()

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

virtual

Implements G4VSolid.

Definition at line 178 of file G4ScaledSolid.cc.

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

References fPtrSolid, fScale, G4VSolid::Inside(), and G4ScaleTransform::Transform().

operator=()

G4ScaledSolid & G4ScaledSolid::operator=

(

const G4ScaledSolid &

rhs

)

Definition at line 88 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;
}

References fCubicVolume, fpPolyhedron, fPtrSolid, fRebuildPolyhedron, fScale, fSurfaceArea, and G4VSolid::operator=().

operator==()

G4bool G4VSolid::operator== ( const G4VSolid &  s ) const

inlineinherited

SetName()

void G4VSolid::SetName ( const G4String &  name )

inherited

Definition at line 127 of file G4VSolid.cc.

{
  fshapeName = name;
  G4SolidStore::GetInstance()->SetMapValid(false);
}

References G4VSolid::fshapeName, G4SolidStore::GetInstance(), G4InuclParticleNames::name(), and G4SolidStore::SetMapValid().

Referenced by export_G4VSolid(), G4MultiUnion::G4MultiUnion(), and G4GDMLRead::StripNames().

SetScaleTransform()

void G4ScaledSolid::SetScaleTransform

(

const G4Scale3D &

scale

)

Definition at line 352 of file G4ScaledSolid.cc.

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

References fRebuildPolyhedron, and fScale.

StreamInfo()

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

virtual

Implements G4VSolid.

Definition at line 392 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;
}

References fPtrSolid, fScale, GetEntityType(), G4VSolid::GetName(), G4ScaleTransform::GetScale(), G4VSolid::StreamInfo(), CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

SurfaceNormal()

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

virtual

Implements G4VSolid.

Definition at line 188 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();
}

References fPtrSolid, fScale, G4ScaleTransform::InverseTransformNormal(), CLHEP::normal(), G4VSolid::SurfaceNormal(), and G4ScaleTransform::Transform().

Field Documentation

fCubicVolume

G4double G4ScaledSolid::fCubicVolume = -1.0

private

Definition at line 120 of file G4ScaledSolid.hh.

Referenced by GetCubicVolume(), and operator=().

fpPolyhedron

G4Polyhedron* G4ScaledSolid::fpPolyhedron = nullptr

mutableprivate

Definition at line 123 of file G4ScaledSolid.hh.

Referenced by GetPolyhedron(), operator=(), and ~G4ScaledSolid().

fPtrSolid

G4VSolid* G4ScaledSolid::fPtrSolid = nullptr

private

Definition at line 118 of file G4ScaledSolid.hh.

Referenced by BoundingLimits(), CalculateExtent(), CreatePolyhedron(), DistanceToIn(), DistanceToOut(), GetCubicVolume(), GetPointOnSurface(), GetUnscaledSolid(), Inside(), operator=(), StreamInfo(), and SurfaceNormal().

fRebuildPolyhedron

G4bool G4ScaledSolid::fRebuildPolyhedron = false

mutableprivate

Definition at line 122 of file G4ScaledSolid.hh.

Referenced by GetPolyhedron(), operator=(), and SetScaleTransform().

fScale

G4ScaleTransform* G4ScaledSolid::fScale = nullptr

private

Definition at line 119 of file G4ScaledSolid.hh.

Referenced by BoundingLimits(), DistanceToIn(), DistanceToOut(), G4ScaledSolid(), GetCubicVolume(), GetPointOnSurface(), GetScaleTransform(), Inside(), operator=(), SetScaleTransform(), StreamInfo(), SurfaceNormal(), and ~G4ScaledSolid().

fshapeName

G4String G4VSolid::fshapeName

privateinherited

Definition at line 312 of file G4VSolid.hh.

Referenced by G4VSolid::operator=(), and G4VSolid::SetName().

fSurfaceArea

G4double G4ScaledSolid::fSurfaceArea = -1.0

private

Definition at line 121 of file G4ScaledSolid.hh.

Referenced by GetSurfaceArea(), and operator=().

kCarTolerance

G4double G4VSolid::kCarTolerance

protectedinherited

Definition at line 299 of file G4VSolid.hh.

Referenced by G4TessellatedSolid::AddFacet(), G4Polycone::CalculateExtent(), G4Polyhedra::CalculateExtent(), G4Tet::CheckDegeneracy(), G4Para::CheckParameters(), G4Trd::CheckParameters(), G4Ellipsoid::CheckParameters(), G4EllipticalTube::CheckParameters(), G4GenericTrap::ComputeIsTwisted(), G4Polyhedra::Create(), G4GenericPolycone::Create(), G4Polycone::Create(), G4CutTubs::CreatePolyhedron(), G4TessellatedSolid::CreateVertexList(), G4VCSGfaceted::DistanceTo(), G4Sphere::DistanceToIn(), G4Ellipsoid::DistanceToIn(), G4Hype::DistanceToIn(), G4Paraboloid::DistanceToIn(), G4VCSGfaceted::DistanceToIn(), G4TessellatedSolid::DistanceToInCore(), G4Cons::DistanceToOut(), G4CutTubs::DistanceToOut(), G4Sphere::DistanceToOut(), G4Torus::DistanceToOut(), G4Tubs::DistanceToOut(), G4GenericTrap::DistanceToOut(), G4Hype::DistanceToOut(), G4Paraboloid::DistanceToOut(), G4VCSGfaceted::DistanceToOut(), G4TessellatedSolid::DistanceToOutCandidates(), G4TessellatedSolid::DistanceToOutCore(), G4TessellatedSolid::DistanceToOutNoVoxels(), G4GenericTrap::DistToPlane(), G4GenericTrap::DistToTriangle(), G4Box::G4Box(), G4Cons::G4Cons(), G4CutTubs::G4CutTubs(), G4EllipticalCone::G4EllipticalCone(), G4ExtrudedSolid::G4ExtrudedSolid(), G4GenericTrap::G4GenericTrap(), G4Hype::G4Hype(), G4Para::G4Para(), G4Sphere::G4Sphere(), G4Tet::G4Tet(), G4Trap::G4Trap(), G4Tubs::G4Tubs(), G4UnionSolid::G4UnionSolid(), G4VSolid::G4VSolid(), G4VTwistedFaceted::G4VTwistedFaceted(), G4GenericPolycone::GetPointOnSurface(), G4Polycone::GetPointOnSurface(), G4UnionSolid::Init(), G4Orb::Initialize(), G4TessellatedSolid::Initialize(), G4SubtractionSolid::Inside(), G4Hype::Inside(), G4Paraboloid::Inside(), G4VCSGfaceted::Inside(), G4VTwistedFaceted::Inside(), G4TessellatedSolid::InsideNoVoxels(), G4GenericTrap::InsidePolygone(), G4TessellatedSolid::InsideVoxels(), G4CutTubs::IsCrossingCutPlanes(), G4GenericTrap::IsSegCrossingZ(), G4Trap::MakePlane(), G4GenericTrap::NormalToPlane(), G4VSolid::operator=(), G4TessellatedSolid::SafetyFromInside(), G4TessellatedSolid::SafetyFromOutside(), G4Torus::SetAllParameters(), G4Polycone::SetOriginalParameters(), G4Polyhedra::SetOriginalParameters(), G4Box::SetXHalfLength(), G4Box::SetYHalfLength(), G4Box::SetZHalfLength(), G4Torus::SurfaceNormal(), G4GenericTrap::SurfaceNormal(), and G4Paraboloid::SurfaceNormal().

---

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

• source/geometry/solids/Boolean/include/G4ScaledSolid.hh
• source/geometry/solids/Boolean/src/G4ScaledSolid.cc