G4USolid Class Reference

#include <G4USolid.hh>

Inheritance diagram for G4USolid:

Public Member Functions
	G4USolid (const G4String &pName, VUSolid *shape)
virtual	~G4USolid ()
G4bool	operator== (const G4USolid &s) const
virtual G4bool	CalculateExtent (const EAxis pAxis, const G4VoxelLimits &pVoxelLimit, const G4AffineTransform &pTransform, G4double &pMin, G4double &pMax) const
virtual EInside	Inside (const G4ThreeVector &p) const
virtual G4ThreeVector	SurfaceNormal (const G4ThreeVector &p) const
virtual G4double	DistanceToIn (const G4ThreeVector &p, const G4ThreeVector &v) const
virtual G4double	DistanceToIn (const G4ThreeVector &p) const
virtual G4double	DistanceToOut (const G4ThreeVector &p, const G4ThreeVector &v, const G4bool calcNorm=false, G4bool *validNorm=0, G4ThreeVector *n=0) const
virtual G4double	DistanceToOut (const G4ThreeVector &p) const
virtual void	ComputeDimensions (G4VPVParameterisation *p, const G4int n, const G4VPhysicalVolume *pRep)
virtual G4double	GetCubicVolume ()
virtual G4double	GetSurfaceArea ()
virtual G4GeometryType	GetEntityType () const
virtual G4ThreeVector	GetPointOnSurface () const
virtual G4VSolid *	Clone () const
virtual std::ostream &	StreamInfo (std::ostream &os) const
virtual void	DescribeYourselfTo (G4VGraphicsScene &scene) const
virtual G4VisExtent	GetExtent () const
G4Polyhedron *	CreatePolyhedron () const
virtual G4Polyhedron *	GetPolyhedron () const
	G4USolid (__void__ &)
	G4USolid (const G4USolid &rhs)
G4USolid &	operator= (const G4USolid &rhs)
VUSolid *	GetSolid () const
Public Member Functions inherited from G4VSolid
	G4VSolid (const G4String &name)
virtual	~G4VSolid ()
G4bool	operator== (const G4VSolid &s) const
G4String	GetName () const
void	SetName (const G4String &name)
G4double	GetTolerance () const
void	DumpInfo () const
virtual const G4VSolid *	GetConstituentSolid (G4int no) const
virtual G4VSolid *	GetConstituentSolid (G4int no)
virtual const G4DisplacedSolid *	GetDisplacedSolidPtr () const
virtual G4DisplacedSolid *	GetDisplacedSolidPtr ()
	G4VSolid (__void__ &)
	G4VSolid (const G4VSolid &rhs)
G4VSolid &	operator= (const G4VSolid &rhs)

Protected Member Functions
G4ThreeVectorList *	CreateRotatedVertices (const G4AffineTransform &pT) const
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
G4double	EstimateCubicVolume (G4int nStat, G4double epsilon) const
G4double	EstimateSurfaceArea (G4int nStat, G4double ell) const

Protected Attributes
VUSolid *	fShape
G4Polyhedron *	fPolyhedron
Protected Attributes inherited from G4VSolid
G4double	kCarTolerance

Detailed Description

Definition at line 46 of file G4USolid.hh.

Constructor & Destructor Documentation

G4USolid::G4USolid	(	const G4String &	pName,
		VUSolid *	shape
	)

Definition at line 44 of file G4USolid.cc.

                                                   :
  G4VSolid(name), fShape(s), fPolyhedron(0)
{
}

G4USolid::~G4USolid ( )

virtual

Definition at line 54 of file G4USolid.cc.

{
}

G4USolid::G4USolid

(

__void__ &

a

)

Definition at line 49 of file G4USolid.cc.

  : G4VSolid(a), fShape(0), fPolyhedron(0)
{
}

G4USolid::G4USolid

(

const G4USolid &

rhs

)

Definition at line 364 of file G4USolid.cc.

References VUSolid::Clone(), and fShape.

  : G4VSolid(rhs), fPolyhedron(rhs.fPolyhedron)
{
  fShape = rhs.fShape->Clone();
}

Member Function Documentation

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

virtual

Implements G4VSolid.

Definition at line 175 of file G4USolid.cc.

References G4VSolid::ClipBetweenSections(), G4VSolid::ClipCrossSection(), CreateRotatedVertices(), VUSolid::eXaxis, VUSolid::ExtentAxis(), VUSolid::eYaxis, VUSolid::eZaxis, fShape, G4VoxelLimits::GetMaxExtent(), G4VoxelLimits::GetMaxXExtent(), G4VoxelLimits::GetMaxYExtent(), G4VoxelLimits::GetMaxZExtent(), G4VoxelLimits::GetMinExtent(), G4VoxelLimits::GetMinXExtent(), G4VoxelLimits::GetMinYExtent(), G4VoxelLimits::GetMinZExtent(), Inside(), G4AffineTransform::Inverse(), G4VoxelLimits::IsLimited(), G4AffineTransform::IsRotated(), G4VSolid::kCarTolerance, kOutside, kXAxis, kYAxis, kZAxis, G4INCL::Math::max(), G4INCL::Math::min(), G4AffineTransform::NetTranslation(), G4AffineTransform::TransformPoint(), CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

Referenced by GetExtent().

{
  if (!pTransform.IsRotated())
  {
    VUSolid::EAxisType eAxis = VUSolid::eXaxis;
    G4double offset = pTransform.NetTranslation().x();
    if (pAxis == kYAxis)
    {
      eAxis = VUSolid::eYaxis;
      offset = pTransform.NetTranslation().y();
    }
    if (pAxis == kZAxis)
    {
      eAxis = VUSolid::eZaxis;
      offset = pTransform.NetTranslation().z();
    }
    fShape->ExtentAxis(eAxis, pMin, pMax);

    pMin += offset;
    pMax += offset;

    if (pVoxelLimit.IsLimited())
    {
      switch (pAxis)
      {
        case kXAxis:
          if ((pMin > pVoxelLimit.GetMaxXExtent() + kCarTolerance) ||
              (pMax < pVoxelLimit.GetMinXExtent() - kCarTolerance))
          {
            return false;
          }
          else
          {
            pMin = std::max(pMin, pVoxelLimit.GetMinXExtent());
            pMax = std::min(pMax, pVoxelLimit.GetMaxXExtent());
          }
          break;
        case kYAxis:
          if ((pMin > pVoxelLimit.GetMaxYExtent() + kCarTolerance) ||
              (pMax < pVoxelLimit.GetMinYExtent() - kCarTolerance))
          {
            return false;
          }
          else
          {
            pMin = std::max(pMin, pVoxelLimit.GetMinYExtent());
            pMax = std::min(pMax, pVoxelLimit.GetMaxYExtent());
          }
          break;
        case kZAxis:
          if ((pMin > pVoxelLimit.GetMaxZExtent() + kCarTolerance) ||
              (pMax < pVoxelLimit.GetMinZExtent() - kCarTolerance))
          {
            return false;
          }
          else
          {
            pMin = std::max(pMin, pVoxelLimit.GetMinZExtent());
            pMax = std::min(pMax, pVoxelLimit.GetMaxZExtent());
          }
          break;
        default:
          break;
      }
      pMin -= kCarTolerance ;
      pMax += kCarTolerance ;
    }
    return true;
  }
  else  // General rotated case - create and clip mesh to boundaries
  {
    // Rotate BoundingBox and Calculate Extent as for BREPS

    G4bool existsAfterClip = false ;
    G4ThreeVectorList* vertices ;

    pMin = +kInfinity ;
    pMax = -kInfinity ;

    // Calculate rotated vertex coordinates

    vertices = CreateRotatedVertices(pTransform) ;
    ClipCrossSection(vertices, 0, pVoxelLimit, pAxis, pMin, pMax) ;
    ClipCrossSection(vertices, 4, pVoxelLimit, pAxis, pMin, pMax) ;
    ClipBetweenSections(vertices, 0, pVoxelLimit, pAxis, pMin, pMax) ;

    if (pVoxelLimit.IsLimited(pAxis) == false)
    {
      if ((pMin != kInfinity) || (pMax != -kInfinity))
      {
        existsAfterClip = true ;

        // Add 2*tolerance to avoid precision troubles

        pMin -= kCarTolerance;
        pMax += kCarTolerance;
      }
    }
    else
    {
      G4ThreeVector clipCentre(
        (pVoxelLimit.GetMinXExtent() + pVoxelLimit.GetMaxXExtent()) * 0.5,
        (pVoxelLimit.GetMinYExtent() + pVoxelLimit.GetMaxYExtent()) * 0.5,
        (pVoxelLimit.GetMinZExtent() + pVoxelLimit.GetMaxZExtent()) * 0.5);

      if ((pMin != kInfinity) || (pMax != -kInfinity))
      {
        existsAfterClip = true ;


        // Check to see if endpoints are in the solid

        clipCentre(pAxis) = pVoxelLimit.GetMinExtent(pAxis);

        if (Inside(pTransform.Inverse().TransformPoint(clipCentre)) != kOutside)
        {
          pMin = pVoxelLimit.GetMinExtent(pAxis);
        }
        else
        {
          pMin -= kCarTolerance;
        }
        clipCentre(pAxis) = pVoxelLimit.GetMaxExtent(pAxis);

        if (Inside(pTransform.Inverse().TransformPoint(clipCentre)) != kOutside)
        {
          pMax = pVoxelLimit.GetMaxExtent(pAxis);
        }
        else
        {
          pMax += kCarTolerance;
        }
      }

      // Check for case where completely enveloping clipping volume
      // If point inside then we are confident that the solid completely
      // envelopes the clipping volume. Hence set min/max extents according
      // to clipping volume extents along the specified axis.

      else if (Inside(pTransform.Inverse().TransformPoint(clipCentre))
               != kOutside)
      {
        existsAfterClip = true ;
        pMin            = pVoxelLimit.GetMinExtent(pAxis) ;
        pMax            = pVoxelLimit.GetMaxExtent(pAxis) ;
      }
    }
    delete vertices;
    return existsAfterClip;
  }
}

G4VSolid * G4USolid::Clone ( ) const

virtual

Reimplemented from G4VSolid.

Reimplemented in G4UPolyhedra, G4UPolycone, G4UTubs, G4UCons, G4USphere, G4UTrd, G4UBox, and G4UOrb.

Definition at line 390 of file G4USolid.cc.

References G4endl, G4Exception(), GetEntityType(), and JustWarning.

{
  std::ostringstream message;
  message << "Clone() method not implemented for type: "
          << GetEntityType() << "!" << G4endl
          << "Returning NULL pointer!";
  G4Exception("G4USolid::Clone()", "GeomSolids1001", JustWarning, message);
  return 0;
}

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

virtual

Reimplemented from G4VSolid.

Reimplemented in G4UPolyhedra, G4UPolycone, G4UTubs, G4UCons, G4USphere, G4UTrd, G4UBox, and G4UOrb.

Definition at line 330 of file G4USolid.cc.

References FatalException, G4endl, and G4Exception().

{
    std::ostringstream message;
    message << "Illegal call to G4USolid::ComputeDimensions()" << G4endl
            << "Method not overloaded by derived class !";
    G4Exception("G4USolid::ComputeDimensions()", "GeomSolids0003",
                FatalException, message);
}

G4Polyhedron * G4USolid::CreatePolyhedron ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 441 of file G4USolid.cc.

References HepPolyhedron::createPolyhedron(), fShape, VUSolid::GetEntityType(), VUSolid::GetParametersList(), and python.hepunit::pi.

Referenced by GetPolyhedron().

{
  G4int index = 0;
  if (fShape->GetEntityType() == "Box")
  {
    double array[3];
    fShape->GetParametersList(index, array);
    return new G4PolyhedronBox(array[0], array[1], array[2]);
  }
  if (fShape->GetEntityType() == "Tubs")
  {
    double array[5];
    fShape->GetParametersList(index, array);
    return new G4PolyhedronTubs(array[0], array[1], array[2], array[3], array[4]);
  }
  if (fShape->GetEntityType() == "Cons")
  {
    double array[7];
    fShape->GetParametersList(index, array);
    return new G4PolyhedronCons(array[0], array[1], array[2], array[3], array[4], array[5], array[6]);
  }
  if (fShape->GetEntityType() == "Orb")
  {
    double array[1];
    fShape->GetParametersList(index, array);
    return new G4PolyhedronSphere(0., array[0], 0., 2 * pi, 0., pi);
  }
  if (fShape->GetEntityType() == "Sphere")
  {
    double array[6];
    fShape->GetParametersList(index, array);
    return new G4PolyhedronSphere(array[0], array[1], array[2], array[3], array[4], array[5]);
  }
  if (fShape->GetEntityType() == "Tet")
  {
    double array[12];
    fShape->GetParametersList(index, array);
    G4Polyhedron* ph = new G4Polyhedron;
    double xyz[4][3];
    static int faces[4][4] = {{1, 3, 2, 0}, {1, 4, 3, 0}, {1, 2, 4, 0}, {2, 3, 4, 0}};
    xyz[0][0] = array[0];
    xyz[0][1] = array[1];
    xyz[0][2] = array[2];
    xyz[1][0] = array[3];
    xyz[1][1] = array[4];
    xyz[1][2] = array[5];
    xyz[2][0] = array[6];
    xyz[2][1] = array[7];
    xyz[2][2] = array[8];
    xyz[3][0] = array[9];
    xyz[3][1] = array[10];
    xyz[3][2] = array[11];

    ph->createPolyhedron(4, 4, xyz, faces);    
    return ph;
  }
  if (fShape->GetEntityType() == "Trd")
  {
    double array[5];
    fShape->GetParametersList(index, array);
    return new G4PolyhedronTrd2(array[0], array[1], array[2], array[3], array[4]);
  }
  if (fShape->GetEntityType() == "Trap")
  {
    double array[12];
    fShape->GetParametersList(index, array);
    double phi = (array[11] != 1.0) ? (std::atan(array[10] / array[9])) : (0.0);
    double alpha1 = std::atan(array[4]);
    double alpha2 = std::atan(array[8]);
    double theta = std::acos(array[11]);

    return new G4PolyhedronTrap(array[0], theta, phi,
                                array[1], array[2], array[3], alpha1,
                                array[5], array[6], array[7], alpha2);
  }

  /*
  if(fShape->GetEntityType()=="TessellatedSolid"){

      G4Polyhedron *uPolyhedron=fShape->GetPolyhedron();
      std::size_t nVertices = (*uPolyhedron).vertices.size();
      std::size_t nFacets   = (*uPolyhedron).facets.size();

      G4PolyhedronArbitrary *polyhedron =
      new G4PolyhedronArbitrary (nVertices, nFacets);

      for (std::vector<UVector3>::const_iterator v = (*uPolyhedron).vertices.begin();
           v!=(*uPolyhedron).vertices.end(); v++)
     {
           UVector3 p=(*v);
           G4ThreeVector pt(p.x,p.y,p.z);

           polyhedron->AddVertex(pt);
      }
      for (std::vector<UFacet>::const_iterator f=(*uPolyhedron).facets.begin();
          f != (*uPolyhedron).facets.end(); f++)
      {
   polyhedron->AddFacet((*f).f1,(*f).f2,(*f).f3,(*f).f4);
      }

     return (G4Polyhedron*) polyhedron;
  }
  */

  return 0;
}

G4ThreeVectorList * G4USolid::CreateRotatedVertices ( const G4AffineTransform &  pT ) const

protected

Definition at line 401 of file G4USolid.cc.

References VUSolid::eXaxis, VUSolid::ExtentAxis(), VUSolid::eYaxis, VUSolid::eZaxis, FatalException, fShape, G4Exception(), and G4AffineTransform::TransformPoint().

Referenced by CalculateExtent().

{
  G4double xMin, xMax, yMin, yMax, zMin, zMax;

  fShape->ExtentAxis(VUSolid::eXaxis, xMin, xMax);
  fShape->ExtentAxis(VUSolid::eYaxis, yMin, yMax);
  fShape->ExtentAxis(VUSolid::eZaxis, zMin, zMax);

  G4ThreeVectorList* vertices;
  vertices = new G4ThreeVectorList();

  if (vertices)
  {
    vertices->reserve(8);
    G4ThreeVector vertex0(xMin, yMin, zMin);
    G4ThreeVector vertex1(xMax, yMin, zMin);
    G4ThreeVector vertex2(xMax, yMax, zMin);
    G4ThreeVector vertex3(xMin, yMax, zMin);
    G4ThreeVector vertex4(xMin, yMin, zMax);
    G4ThreeVector vertex5(xMax, yMin, zMax);
    G4ThreeVector vertex6(xMax, yMax, zMax);
    G4ThreeVector vertex7(xMin, yMax, zMax);

    vertices->push_back(pTransform.TransformPoint(vertex0));
    vertices->push_back(pTransform.TransformPoint(vertex1));
    vertices->push_back(pTransform.TransformPoint(vertex2));
    vertices->push_back(pTransform.TransformPoint(vertex3));
    vertices->push_back(pTransform.TransformPoint(vertex4));
    vertices->push_back(pTransform.TransformPoint(vertex5));
    vertices->push_back(pTransform.TransformPoint(vertex6));
    vertices->push_back(pTransform.TransformPoint(vertex7));
  }
  else
  {
    G4Exception("G4VUSolid::CreateRotatedVertices()", "FatalError",
                FatalException, "Out of memory - Cannot allocate vertices!");
  }
  return vertices;
}

void G4USolid::DescribeYourselfTo ( G4VGraphicsScene &  scene ) const

virtual

Implements G4VSolid.

Definition at line 341 of file G4USolid.cc.

References G4VGraphicsScene::AddSolid().

{
  scene.AddSolid(*this);
}

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

virtual

Implements G4VSolid.

Definition at line 91 of file G4USolid.cc.

References VUSolid::DistanceToIn(), fShape, test::v, CLHEP::Hep3Vector::x(), UVector3::x, CLHEP::Hep3Vector::y(), UVector3::y, CLHEP::Hep3Vector::z(), and UVector3::z.

{
  UVector3 p;
  p.x = pt.x();
  p.y = pt.y();
  p.z = pt.z(); // better assign at construction
  UVector3 v;
  v.x = d.x();
  v.y = d.y();
  v.z = d.z(); // better assign at construction
  G4double dist = fShape->DistanceToIn(p, v);
  if (dist > kInfinity) dist = kInfinity;
  return dist;
}

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

virtual

Implements G4VSolid.

Definition at line 107 of file G4USolid.cc.

References fShape, VUSolid::SafetyFromOutside(), CLHEP::Hep3Vector::x(), UVector3::x, CLHEP::Hep3Vector::y(), UVector3::y, CLHEP::Hep3Vector::z(), and UVector3::z.

{
  UVector3 p;
  p.x = pt.x();
  p.y = pt.y();
  p.z = pt.z(); // better assign at construction
  G4double dist = fShape->SafetyFromOutside(p); // true?
  if (dist > kInfinity) dist = kInfinity;
  return dist;
}

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

virtual

Implements G4VSolid.

Definition at line 118 of file G4USolid.cc.

References VUSolid::DistanceToOut(), fShape, n, CLHEP::Hep3Vector::setX(), CLHEP::Hep3Vector::setY(), CLHEP::Hep3Vector::setZ(), test::v, CLHEP::Hep3Vector::x(), UVector3::x, CLHEP::Hep3Vector::y(), UVector3::y, CLHEP::Hep3Vector::z(), and UVector3::z.

{
  UVector3 p;
  p.x = pt.x();
  p.y = pt.y();
  p.z = pt.z(); // better assign at construction
  UVector3 v;
  v.x = d.x();
  v.y = d.y();
  v.z = d.z(); // better assign at construction
  UVector3 n;
  bool valid;
  G4double dist = fShape->DistanceToOut(p, v, n,valid); // should use local variable
  if(calcNorm)
  {
    if(valid){ *validNorm = true;}
    else {* validNorm =false;}
    if(*validNorm)
    { norm->setX(n.x);
      norm->setY(n.y);
      norm->setZ(n.z);
    } // *norm = n, but only after calcNorm check
  }
  if (dist > kInfinity) dist = kInfinity;
  return dist;
}

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

virtual

Implements G4VSolid.

Definition at line 149 of file G4USolid.cc.

References fShape, VUSolid::SafetyFromInside(), CLHEP::Hep3Vector::x(), UVector3::x, CLHEP::Hep3Vector::y(), UVector3::y, CLHEP::Hep3Vector::z(), and UVector3::z.

{
  UVector3 p;
  p.x = pt.x();
  p.y = pt.y();
  p.z = pt.z(); // better assign at construction
  return fShape->SafetyFromInside(p); // true?
}

G4double G4USolid::GetCubicVolume ( )

virtual

Reimplemented from G4VSolid.

Definition at line 158 of file G4USolid.cc.

References VUSolid::Capacity(), and fShape.

{
  return fShape->Capacity();
}

G4GeometryType G4USolid::GetEntityType ( ) const

virtual

Implements G4VSolid.

Definition at line 346 of file G4USolid.cc.

References fShape, and VUSolid::GetEntityType().

Referenced by Clone().

{

  G4String string = fShape->GetEntityType();
  return "G4" + string;
}

G4VisExtent G4USolid::GetExtent ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 554 of file G4USolid.cc.

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

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

G4ThreeVector G4USolid::GetPointOnSurface ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 168 of file G4USolid.cc.

References fShape, VUSolid::GetPointOnSurface(), UVector3::x, UVector3::y, and UVector3::z.

{
  UVector3 p;
  p = fShape->GetPointOnSurface();
  return G4ThreeVector(p.x, p.y, p.z);
}

G4Polyhedron * G4USolid::GetPolyhedron ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 548 of file G4USolid.cc.

References CreatePolyhedron(), and fPolyhedron.

{
  if (!fPolyhedron) fPolyhedron = CreatePolyhedron();
  return fPolyhedron;
}

VUSolid* G4USolid::GetSolid ( ) const

inline

Definition at line 171 of file G4USolid.hh.

References fShape.

    {
      return fShape;
    }

G4double G4USolid::GetSurfaceArea ( )

virtual

Reimplemented from G4VSolid.

Definition at line 163 of file G4USolid.cc.

References fShape, and VUSolid::SurfaceArea().

{
  return fShape->SurfaceArea();
}

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

virtual

Implements G4VSolid.

Definition at line 63 of file G4USolid.cc.

References VUSolid::eInside, VUSolid::eSurface, fShape, VUSolid::Inside(), kInside, kOutside, kSurface, CLHEP::Hep3Vector::x(), UVector3::x, CLHEP::Hep3Vector::y(), UVector3::y, CLHEP::Hep3Vector::z(), and UVector3::z.

Referenced by CalculateExtent().

{
  UVector3 pt;
  VUSolid::EnumInside in_temp;
  EInside in = kOutside;
  pt.x = p.x();
  pt.y = p.y();
  pt.z = p.z(); // better assign at construction

  in_temp = fShape->Inside(pt);

  if (in_temp == VUSolid::eSurface)return kSurface;
  if (in_temp == VUSolid::eInside)return kInside;

  return in;
}

G4USolid & G4USolid::operator=

(

const G4USolid &

rhs

)

Definition at line 370 of file G4USolid.cc.

References VUSolid::Clone(), fShape, and G4VSolid::operator=().

Referenced by G4UOrb::operator=(), G4UTet::operator=(), G4UGenericPolycone::operator=(), G4UBox::operator=(), G4UTrd::operator=(), G4UTubs::operator=(), G4USphere::operator=(), G4UCons::operator=(), G4UPolycone::operator=(), and G4UPolyhedra::operator=().

{
  // Check assignment to self
  //
  if (this == &rhs)
  {
    return *this;
  }

  // Copy base class data
  //
  G4VSolid::operator=(rhs);

  // Copy data
  //
  fShape = rhs.fShape->Clone();

  return *this;
}

G4bool G4USolid::operator==

(

const G4USolid &

s

)

const

Definition at line 58 of file G4USolid.cc.

{
  return (this == &s) ? true : false;
}

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

virtual

Implements G4VSolid.

Definition at line 353 of file G4USolid.cc.

References fShape, and VUSolid::GetName().

{
  os << "-----------------------------------------------------------\n"
     << "    *** Dump for solid - " << fShape->GetName() << " ***\n";
  //   << "    ===================================================\n"
  //   << " Solid type: " << fShape->GetEntityType() << "\n"
  //   << "-----------------------------------------------------------\n";

  return os;//fShape->StreamInfo(os);
}

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

virtual

Implements G4VSolid.

Definition at line 80 of file G4USolid.cc.

References fShape, n, VUSolid::Normal(), CLHEP::Hep3Vector::x(), UVector3::x, CLHEP::Hep3Vector::y(), UVector3::y, CLHEP::Hep3Vector::z(), and UVector3::z.

{
  UVector3 p;
  p.x = pt.x();
  p.y = pt.y();
  p.z = pt.z();
  UVector3 n;
  fShape->Normal(p, n);
  return G4ThreeVector(n.x, n.y, n.z);
}

Field Documentation

G4Polyhedron* G4USolid::fPolyhedron

mutableprotected

Definition at line 183 of file G4USolid.hh.

Referenced by GetPolyhedron(), G4UTrd::SetAllParameters(), G4USphere::SetDeltaPhiAngle(), G4UTubs::SetDeltaPhiAngle(), G4UCons::SetDeltaPhiAngle(), G4USphere::SetDeltaThetaAngle(), G4USphere::SetInnerRadius(), G4UTubs::SetInnerRadius(), G4UCons::SetInnerRadiusMinusZ(), G4UCons::SetInnerRadiusPlusZ(), G4UPolycone::SetOriginalParameters(), G4UPolyhedra::SetOriginalParameters(), G4USphere::SetOuterRadius(), G4UTubs::SetOuterRadius(), G4UCons::SetOuterRadiusMinusZ(), G4UCons::SetOuterRadiusPlusZ(), G4UOrb::SetRadius(), G4UTubs::SetStartPhiAngle(), G4UCons::SetStartPhiAngle(), G4USphere::SetStartThetaAngle(), G4UBox::SetXHalfLength(), G4UTrd::SetXHalfLength1(), G4UTrd::SetXHalfLength2(), G4UBox::SetYHalfLength(), G4UTrd::SetYHalfLength1(), G4UTrd::SetYHalfLength2(), G4UBox::SetZHalfLength(), G4UTrd::SetZHalfLength(), G4UTubs::SetZHalfLength(), and G4UCons::SetZHalfLength().

VUSolid* G4USolid::fShape

protected

Definition at line 182 of file G4USolid.hh.

Referenced by CalculateExtent(), CreatePolyhedron(), CreateRotatedVertices(), DistanceToIn(), DistanceToOut(), G4USolid(), GetCubicVolume(), GetEntityType(), GetPointOnSurface(), G4UOrb::GetShape(), G4UBox::GetShape(), G4UGenericPolycone::GetShape(), G4UTrd::GetShape(), G4UTet::GetShape(), G4USphere::GetShape(), G4UCons::GetShape(), G4UTubs::GetShape(), G4UPolycone::GetShape(), G4UPolyhedra::GetShape(), GetSolid(), GetSurfaceArea(), Inside(), operator=(), StreamInfo(), and SurfaceNormal().

---

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

• G4USolid.hh
• G4USolid.cc