G4TessellatedSolid Class Reference

#include <G4TessellatedSolid.hh>

Inheritance diagram for G4TessellatedSolid:

Public Member Functions
	G4TessellatedSolid ()
virtual	~G4TessellatedSolid ()
	G4TessellatedSolid (const G4String &name)
	G4TessellatedSolid (__void__ &)
	G4TessellatedSolid (const G4TessellatedSolid &ts)
G4TessellatedSolid &	operator= (const G4TessellatedSolid &right)
G4TessellatedSolid &	operator+= (const G4TessellatedSolid &right)
G4bool	AddFacet (G4VFacet *aFacet)
G4VFacet *	GetFacet (G4int i) const
G4int	GetNumberOfFacets () 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
virtual G4double	DistanceToOut (const G4ThreeVector &p, const G4ThreeVector &v, const G4bool calcNorm, G4bool *validNorm, G4ThreeVector *norm) const
virtual G4bool	Normal (const G4ThreeVector &p, G4ThreeVector &n) const
virtual G4double	SafetyFromOutside (const G4ThreeVector &p, G4bool aAccurate=false) const
virtual G4double	SafetyFromInside (const G4ThreeVector &p, G4bool aAccurate=false) const
virtual G4GeometryType	GetEntityType () const
virtual std::ostream &	StreamInfo (std::ostream &os) const
virtual G4VSolid *	Clone () const
virtual G4ThreeVector	GetPointOnSurface () const
virtual G4double	GetSurfaceArea ()
virtual G4double	GetCubicVolume ()
void	SetSolidClosed (const G4bool t)
G4bool	GetSolidClosed () const
void	SetMaxVoxels (G4int max)
G4SurfaceVoxelizer &	GetVoxels ()
virtual G4bool	CalculateExtent (const EAxis pAxis, const G4VoxelLimits &pVoxelLimit, const G4AffineTransform &pTransform, G4double &pMin, G4double &pMax) const
G4double	GetMinXExtent () const
G4double	GetMaxXExtent () const
G4double	GetMinYExtent () const
G4double	GetMaxYExtent () const
G4double	GetMinZExtent () const
G4double	GetMaxZExtent () const
G4ThreeVectorList *	CreateRotatedVertices (const G4AffineTransform &pT) const
virtual G4Polyhedron *	CreatePolyhedron () const
virtual G4Polyhedron *	GetPolyhedron () const
virtual void	DescribeYourselfTo (G4VGraphicsScene &scene) const
virtual G4VisExtent	GetExtent () const
G4int	AllocatedMemoryWithoutVoxels ()
G4int	AllocatedMemory ()
void	DisplayAllocatedMemory ()
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
virtual void	ComputeDimensions (G4VPVParameterisation *p, const G4int n, const G4VPhysicalVolume *pRep)
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)

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
G4double	EstimateCubicVolume (G4int nStat, G4double epsilon) const
G4double	EstimateSurfaceArea (G4int nStat, G4double ell) const
Protected Attributes inherited from G4VSolid
G4double	kCarTolerance

Detailed Description

Definition at line 128 of file G4TessellatedSolid.hh.

Constructor & Destructor Documentation

G4TessellatedSolid::G4TessellatedSolid

(

)

Definition at line 101 of file G4TessellatedSolid.cc.

Referenced by Clone().

                                        : G4VSolid("dummy")
{
  Initialize();
}

G4TessellatedSolid::~G4TessellatedSolid ( )

virtual

Definition at line 131 of file G4TessellatedSolid.cc.

{
  DeleteObjects ();
}

G4TessellatedSolid::G4TessellatedSolid

(

const G4String &

name

)

Definition at line 111 of file G4TessellatedSolid.cc.

  : G4VSolid(name)
{
  Initialize();
}

G4TessellatedSolid::G4TessellatedSolid

(

__void__ &

a

)

Definition at line 122 of file G4TessellatedSolid.cc.

References CLHEP::Hep3Vector::set().

                                                   : G4VSolid(a)
{
  Initialize();
  fMinExtent.set(0,0,0);
  fMaxExtent.set(0,0,0);
}

G4TessellatedSolid::G4TessellatedSolid

(

const G4TessellatedSolid &

ts

)

Definition at line 140 of file G4TessellatedSolid.cc.

  : G4VSolid(ts), fpPolyhedron(0)
{
  Initialize();

  CopyObjects(ts);
}

Member Function Documentation

G4bool G4TessellatedSolid::AddFacet

(

G4VFacet *

aFacet

)

Definition at line 220 of file G4TessellatedSolid.cc.

References G4cout, G4Exception(), G4VFacet::GetCircumcentre(), G4VertexInfo::id, G4VFacet::IsDefined(), JustWarning, G4VSolid::kCarTolerance, G4VertexInfo::mag2, G4VFacet::StreamInfo(), CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

Referenced by G4tgbVolume::FindOrConstructG4Solid(), operator+=(), and G4GDMLReadSolids::TessellatedRead().

{
  // Add the facet to the vector.
  //
  if (fSolidClosed)
  {
    G4Exception("G4TessellatedSolid::AddFacet()", "GeomSolids1002",
                JustWarning, "Attempt to add facets when solid is closed.");
    return false;
  }
  else if (aFacet->IsDefined())
  {
    set<G4VertexInfo,G4VertexComparator>::iterator begin
      = fFacetList.begin(), end = fFacetList.end(), pos, it;
    G4ThreeVector p = aFacet->GetCircumcentre();
    G4VertexInfo value;
    value.id = fFacetList.size();
    value.mag2 = p.x() + p.y() + p.z();

    G4bool found = false;
    if (!OutsideOfExtent(p, kCarTolerance))
    {
      G4double kCarTolerance3 = 3 * kCarTolerance;
      pos = fFacetList.lower_bound(value);

      it = pos;
      while (!found && it != end)
      {
        G4int id = (*it).id;
        G4VFacet *facet = fFacets[id];
        G4ThreeVector q = facet->GetCircumcentre();
        if ((found = (facet == aFacet))) break;
        G4double dif = q.x() + q.y() + q.z() - value.mag2;
        if (dif > kCarTolerance3) break;
        it++;
      }

      if (fFacets.size() > 1)
      {
        it = pos;
        while (!found && it != begin)
        {
          --it;
          G4int id = (*it).id;
          G4VFacet *facet = fFacets[id];      
          G4ThreeVector q = facet->GetCircumcentre();
          found = (facet == aFacet);
          if (found) break;
          G4double dif = value.mag2 - (q.x() + q.y() + q.z());
          if (dif > kCarTolerance3) break;
        }
      }
    }

    if (!found)
    {
      fFacets.push_back(aFacet);
      fFacetList.insert(value);
    }

    return true;
  }
  else
  {
    G4Exception("G4TessellatedSolid::AddFacet()", "GeomSolids1002",
                JustWarning, "Attempt to add facet not properly defined.");    
    aFacet->StreamInfo(G4cout);
    return false;
  }
}

G4int G4TessellatedSolid::AllocatedMemory

(

)

Definition at line 2031 of file G4TessellatedSolid.cc.

References G4SurfaceVoxelizer::AllocatedMemory(), AllocatedMemoryWithoutVoxels(), and G4SurfBits::GetNbytes().

Referenced by DisplayAllocatedMemory().

{
  G4int size = AllocatedMemoryWithoutVoxels();
  G4int sizeInsides = fInsides.GetNbytes();
  G4int sizeVoxels = fVoxels.AllocatedMemory();
  size += sizeInsides + sizeVoxels;
  return size;
}

G4int G4TessellatedSolid::AllocatedMemoryWithoutVoxels

(

)

Definition at line 2005 of file G4TessellatedSolid.cc.

References G4VFacet::AllocatedMemory().

Referenced by AllocatedMemory(), and DisplayAllocatedMemory().

{
  G4int base = sizeof(*this);
  base += fVertexList.capacity() * sizeof(G4ThreeVector);
  base += fRandir.capacity() * sizeof(G4ThreeVector);

  G4int limit = fFacets.size();
  for (G4int i = 0; i < limit; i++)
  {
    G4VFacet &facet = *fFacets[i];
    base += facet.AllocatedMemory();
  }

  std::set<G4VFacet *>::const_iterator beg, end, it;
  beg = fExtremeFacets.begin();
  end = fExtremeFacets.end();
  for (it = beg; it != end; it++)
  {
    G4VFacet &facet = *(*it);
    base += facet.AllocatedMemory();
  }
  return base;
}

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

virtual

Implements G4VSolid.

Definition at line 1782 of file G4TessellatedSolid.cc.

References G4AffineTransform::ApplyPointTransform(), G4VoxelLimits::GetMaxExtent(), G4VoxelLimits::GetMinExtent(), G4VoxelLimits::IsLimited(), G4VSolid::kCarTolerance, kXAxis, kYAxis, kZAxis, CLHEP::Hep3Vector::SIZE, CLHEP::Hep3Vector::X, CLHEP::Hep3Vector::Y, and CLHEP::Hep3Vector::Z.

Referenced by G4GenericTrap::CalculateExtent().

{
  G4ThreeVectorList transVertexList(fVertexList);
  G4int size = fVertexList.size();

  // Put solid into transformed frame
  for (G4int i=0; i < size; ++i)
  {
    pTransform.ApplyPointTransform(transVertexList[i]);
  }

  // Find min and max extent in each dimension
  G4ThreeVector minExtent(kInfinity, kInfinity, kInfinity);
  G4ThreeVector maxExtent(-kInfinity, -kInfinity, -kInfinity);

  size = transVertexList.size();
  for (G4int i=0; i< size; ++i)
  {
    for (G4int axis=G4ThreeVector::X; axis < G4ThreeVector::SIZE; ++axis)
    {
      G4double coordinate = transVertexList[i][axis];
      if (coordinate < minExtent[axis])
      { minExtent[axis] = coordinate; }
      if (coordinate > maxExtent[axis])
      { maxExtent[axis] = coordinate; }
    }
  }

  // Check for containment and clamp to voxel boundaries
  for (G4int axis=G4ThreeVector::X; axis < G4ThreeVector::SIZE; ++axis)
  {
    EAxis geomAxis = kXAxis; // U geom classes use different index type
    switch(axis)
    {
    case G4ThreeVector::X: geomAxis = kXAxis; break;
    case G4ThreeVector::Y: geomAxis = kYAxis; break;
    case G4ThreeVector::Z: geomAxis = kZAxis; break;
    }
    G4bool isLimited = pVoxelLimit.IsLimited(geomAxis);
    G4double voxelMinExtent = pVoxelLimit.GetMinExtent(geomAxis);
    G4double voxelMaxExtent = pVoxelLimit.GetMaxExtent(geomAxis);

    if (isLimited)
    {
      if ( minExtent[axis] > voxelMaxExtent+kCarTolerance ||
        maxExtent[axis] < voxelMinExtent-kCarTolerance    )
      {
        return false ;
      }
      else
      {
        if (minExtent[axis] < voxelMinExtent)
        {
          minExtent[axis] = voxelMinExtent ;
        }
        if (maxExtent[axis] > voxelMaxExtent)
        {
          maxExtent[axis] = voxelMaxExtent;
        }
      }
    }
  }

  // Convert pAxis into G4ThreeVector index
  G4int vecAxis=0;
  switch(pAxis)
  {
  case kXAxis: vecAxis = G4ThreeVector::X; break;
  case kYAxis: vecAxis = G4ThreeVector::Y; break;
  case kZAxis: vecAxis = G4ThreeVector::Z; break;
  default: break;
  } 

  pMin = minExtent[vecAxis] - kCarTolerance;
  pMax = maxExtent[vecAxis] + kCarTolerance;

  return true;
}

G4VSolid * G4TessellatedSolid::Clone ( ) const

virtual

Reimplemented from G4VSolid.

Reimplemented in G4ExtrudedSolid.

Definition at line 1611 of file G4TessellatedSolid.cc.

References G4TessellatedSolid().

{
  return new G4TessellatedSolid(*this);
}

G4Polyhedron * G4TessellatedSolid::CreatePolyhedron ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 1727 of file G4TessellatedSolid.cc.

References G4PolyhedronArbitrary::AddFacet(), G4PolyhedronArbitrary::AddVertex(), G4VFacet::GetNumberOfVertices(), G4VFacet::GetVertexIndex(), n, G4PolyhedronArbitrary::SetReferences(), and test::v.

Referenced by G4GenericTrap::CreatePolyhedron(), and GetPolyhedron().

{
  G4int nVertices = fVertexList.size();
  G4int nFacets   = fFacets.size();
  G4PolyhedronArbitrary *polyhedron =
    new G4PolyhedronArbitrary (nVertices, nFacets);
  for (G4ThreeVectorList::const_iterator v= fVertexList.begin();
                                         v!=fVertexList.end(); ++v)
  {
    polyhedron->AddVertex(*v);
  }

  G4int size = fFacets.size();
  for (G4int i = 0; i < size; ++i)
  {
    G4VFacet &facet = *fFacets[i];
    G4int v[4];
    G4int n = facet.GetNumberOfVertices();
    if (n > 4) n = 4;
    else if (n == 3) v[3] = 0;
    for (G4int j=0; j<n; ++j)
    {
      G4int k = facet.GetVertexIndex(j);
      v[j] = k+1;
    }
    polyhedron->AddFacet(v[0],v[1],v[2],v[3]);
  }
  polyhedron->SetReferences();  

  return (G4Polyhedron*) polyhedron;
}

G4ThreeVectorList* G4TessellatedSolid::CreateRotatedVertices

(

const G4AffineTransform &

pT

)

const

void G4TessellatedSolid::DescribeYourselfTo ( G4VGraphicsScene &  scene ) const

virtual

Implements G4VSolid.

Definition at line 1720 of file G4TessellatedSolid.cc.

References G4VGraphicsScene::AddSolid().

Referenced by G4GenericTrap::DescribeYourselfTo().

{
  scene.AddSolid (*this);
}

void G4TessellatedSolid::DisplayAllocatedMemory

(

)

Definition at line 567 of file G4TessellatedSolid.cc.

References AllocatedMemory(), AllocatedMemoryWithoutVoxels(), G4cout, and G4endl.

Referenced by SetSolidClosed().

{
  G4int without = AllocatedMemoryWithoutVoxels();
  G4int with = AllocatedMemory();
  G4double ratio = (G4double) with / without;
  G4cout << "G4TessellatedSolid - Allocated memory without voxel overhead "
         << without << "; with " << with << "; ratio: " << ratio << G4endl;  
}

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

virtual

Implements G4VSolid.

Definition at line 1664 of file G4TessellatedSolid.cc.

Referenced by G4GenericTrap::DistanceToIn(), and SafetyFromInside().

{
  return DistanceToInCore(p,v,kInfinity);
}

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

virtual

Implements G4VSolid.

Definition at line 1657 of file G4TessellatedSolid.cc.

References SafetyFromOutside().

{
  return SafetyFromOutside(p,false);
}

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

virtual

Implements G4VSolid.

Reimplemented in G4ExtrudedSolid.

Definition at line 1677 of file G4TessellatedSolid.cc.

References SafetyFromInside().

Referenced by G4GenericTrap::DistanceToOut(), G4ExtrudedSolid::DistanceToOut(), and SafetyFromOutside().

{
  return SafetyFromInside(p,false);
}

G4double G4TessellatedSolid::DistanceToOut ( const G4ThreeVector &  p, const G4ThreeVector &  v, const G4bool  calcNorm, G4bool *  validNorm, G4ThreeVector *  norm  ) const

virtual

Implements G4VSolid.

Reimplemented in G4ExtrudedSolid.

Definition at line 1700 of file G4TessellatedSolid.cc.

References n.

{
  G4ThreeVector n;
  G4bool valid;

  G4double dist = DistanceToOutCore(p, v, n, valid);
  if (calcNorm)
  {
    *norm = n;
    *validNorm = valid;
  }
  return dist;
}

G4double G4TessellatedSolid::GetCubicVolume ( )

virtual

Reimplemented from G4VSolid.

Definition at line 1915 of file G4TessellatedSolid.cc.

References G4VSolid::GetCubicVolume().

{
  if(fCubicVolume != 0.) {;}
  else   { fCubicVolume = G4VSolid::GetCubicVolume(); }
  return fCubicVolume;
}

G4GeometryType G4TessellatedSolid::GetEntityType ( ) const

virtual

Implements G4VSolid.

Reimplemented in G4ExtrudedSolid.

Definition at line 1582 of file G4TessellatedSolid.cc.

{
  return fGeometryType;
}

G4VisExtent G4TessellatedSolid::GetExtent ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 1908 of file G4TessellatedSolid.cc.

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

Referenced by G4GenericTrap::GetExtent().

{
  return G4VisExtent (fMinExtent.x(), fMaxExtent.x(), fMinExtent.y(), fMaxExtent.y(), fMinExtent.z(), fMaxExtent.z());
}

G4VFacet * G4TessellatedSolid::GetFacet ( G4int  i ) const

inline

Definition at line 302 of file G4TessellatedSolid.hh.

Referenced by operator+=(), and G4GDMLWriteSolids::TessellatedWrite().

{
  return fFacets[i];
}

G4double G4TessellatedSolid::GetMaxXExtent

(

)

const

Definition at line 1873 of file G4TessellatedSolid.cc.

References CLHEP::Hep3Vector::x().

Referenced by G4ExtrudedSolid::Inside().

{
  return fMaxExtent.x();
}

G4double G4TessellatedSolid::GetMaxYExtent

(

)

const

Definition at line 1887 of file G4TessellatedSolid.cc.

References CLHEP::Hep3Vector::y().

Referenced by G4ExtrudedSolid::Inside().

{
  return fMaxExtent.y();
}

G4double G4TessellatedSolid::GetMaxZExtent

(

)

const

Definition at line 1901 of file G4TessellatedSolid.cc.

References CLHEP::Hep3Vector::z().

Referenced by G4ExtrudedSolid::Inside().

{
  return fMaxExtent.z();
}

G4double G4TessellatedSolid::GetMinXExtent

(

)

const

Definition at line 1866 of file G4TessellatedSolid.cc.

References CLHEP::Hep3Vector::x().

Referenced by G4ExtrudedSolid::Inside().

{
  return fMinExtent.x();
}

G4double G4TessellatedSolid::GetMinYExtent

(

)

const

Definition at line 1880 of file G4TessellatedSolid.cc.

References CLHEP::Hep3Vector::y().

Referenced by G4ExtrudedSolid::Inside().

{
  return fMinExtent.y();
}

G4double G4TessellatedSolid::GetMinZExtent

(

)

const

Definition at line 1894 of file G4TessellatedSolid.cc.

References CLHEP::Hep3Vector::z().

Referenced by G4ExtrudedSolid::Inside().

{
  return fMinExtent.z();
}

G4int G4TessellatedSolid::GetNumberOfFacets

(

)

const

Definition at line 639 of file G4TessellatedSolid.cc.

Referenced by operator+=(), and G4GDMLWriteSolids::TessellatedWrite().

{
  return fFacets.size();
}

G4ThreeVector G4TessellatedSolid::GetPointOnSurface ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 1939 of file G4TessellatedSolid.cc.

References G4INCL::DeJongSpin::shoot().

Referenced by G4GenericTrap::GetPointOnSurface().

{
  // Select randomly a facet and return a random point on it

  G4int i = (G4int) G4RandFlat::shoot(0., fFacets.size());
  return fFacets[i]->GetPointOnFace();
}

G4Polyhedron * G4TessellatedSolid::GetPolyhedron ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 1763 of file G4TessellatedSolid.cc.

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

Referenced by G4GenericTrap::GetPolyhedron().

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

G4bool G4TessellatedSolid::GetSolidClosed

(

)

const

Definition at line 611 of file G4TessellatedSolid.cc.

{
  return fSolidClosed;
}

G4double G4TessellatedSolid::GetSurfaceArea ( )

virtual

Reimplemented from G4VSolid.

Definition at line 1924 of file G4TessellatedSolid.cc.

References G4VFacet::GetArea().

{
  if (fSurfaceArea != 0.) return fSurfaceArea;

  G4int size = fFacets.size();
  for (G4int i = 0; i < size; ++i)
  {
    G4VFacet &facet = *fFacets[i];
    fSurfaceArea += facet.GetArea();
  }
  return fSurfaceArea;
}

G4SurfaceVoxelizer & G4TessellatedSolid::GetVoxels ( )

inline

Definition at line 312 of file G4TessellatedSolid.hh.

{
  return fVoxels;
}

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

virtual

Implements G4VSolid.

Reimplemented in G4ExtrudedSolid.

Definition at line 1626 of file G4TessellatedSolid.cc.

References G4SurfaceVoxelizer::GetCountOfVoxels().

Referenced by G4GenericTrap::Inside(), SafetyFromInside(), and SafetyFromOutside().

{
  EInside location;

  if (fVoxels.GetCountOfVoxels() > 1)
  {
    location = InsideVoxels(aPoint);
  }
  else
  {
    location = InsideNoVoxels(aPoint);
  }
  return location;
}

G4bool G4TessellatedSolid::Normal ( const G4ThreeVector &  p, G4ThreeVector &  n  ) const

virtual

Definition at line 983 of file G4TessellatedSolid.cc.

References G4VFacet::Distance(), G4Exception(), G4SurfaceVoxelizer::GetCandidates(), G4SurfaceVoxelizer::GetCountOfVoxels(), G4VFacet::GetSurfaceNormal(), G4SurfaceVoxelizer::GetVoxel(), JustWarning, and CLHEP::Hep3Vector::z().

Referenced by SurfaceNormal().

{
  G4double minDist;
  G4VFacet *facet = 0;

  if (fVoxels.GetCountOfVoxels() > 1)
  {
    vector<G4int> curVoxel(3);
    fVoxels.GetVoxel(curVoxel, p);
    const vector<G4int> &candidates = fVoxels.GetCandidates(curVoxel);
    // fVoxels.GetCandidatesVoxelArray(p, candidates, 0);

    if (G4int limit = candidates.size())
    {
      minDist = kInfinity;
      for(G4int i = 0 ; i < limit ; ++i)
      {      
        G4int candidate = candidates[i];
        G4VFacet &fct = *fFacets[candidate];
        G4double dist = fct.Distance(p,minDist);
        if (dist < minDist) minDist = dist;
        if (dist <= kCarToleranceHalf)
        {
          aNormal = fct.GetSurfaceNormal();
          return true;
        }
      }
    }
    minDist = MinDistanceFacet(p, true, facet);
  }
  else
  {
    minDist = kInfinity;
    G4int size = fFacets.size();
    for (G4int i = 0; i < size; ++i)
    {
      G4VFacet &f = *fFacets[i];
      G4double dist = f.Distance(p, minDist);
      if (dist < minDist)
      {
        minDist  = dist;
        facet = &f;
      }
    }
  }

  if (minDist != kInfinity)
  {
    if (facet)  { aNormal = facet->GetSurfaceNormal(); }
    return minDist <= kCarToleranceHalf;
  }
  else
  {
#ifdef G4VERBOSE
    std::ostringstream message;
    message << "Point p is not on surface !?" << G4endl
      << "          No facets found for point: " << p << " !" << G4endl
      << "          Returning approximated value for normal.";

    G4Exception("G4TessellatedSolid::SurfaceNormal(p)",
                "GeomSolids1002", JustWarning, message );
#endif
    aNormal = (p.z() > 0 ? G4ThreeVector(0,0,1) : G4ThreeVector(0,0,-1));
    return false;
  }
}

G4TessellatedSolid & G4TessellatedSolid::operator+=

(

const G4TessellatedSolid &

right

)

Definition at line 626 of file G4TessellatedSolid.cc.

References AddFacet(), G4VFacet::GetClone(), GetFacet(), and GetNumberOfFacets().

{
  G4int size = right.GetNumberOfFacets();
  for (G4int i = 0; i < size; ++i)
    AddFacet(right.GetFacet(i)->GetClone());

  return *this;
}

G4TessellatedSolid & G4TessellatedSolid::operator=

(

const G4TessellatedSolid &

right

)

Definition at line 153 of file G4TessellatedSolid.cc.

References G4VSolid::operator=().

Referenced by G4ExtrudedSolid::operator=().

{
  if (&ts == this) return *this;

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

  DeleteObjects ();

  Initialize();

  CopyObjects (ts);

  return *this;
}

G4double G4TessellatedSolid::SafetyFromInside ( const G4ThreeVector &  p, G4bool  aAccurate = false  ) const

virtual

Definition at line 1533 of file G4TessellatedSolid.cc.

References G4VFacet::Distance(), DistanceToIn(), G4Exception(), G4SurfaceVoxelizer::GetCountOfVoxels(), Inside(), JustWarning, G4VSolid::kCarTolerance, kOutside, python.hepunit::mm, CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

Referenced by DistanceToOut().

{  
#if G4SPECSDEBUG
  if ( Inside(p) == kOutside )
  {
    std::ostringstream message;
    G4int oldprc = message.precision(16) ;
    message << "Point p is already outside!?" << G4endl
      << "Position:"  << G4endl << G4endl
      << "p.x() = "   << p.x()/mm << " mm" << G4endl
      << "p.y() = "   << p.y()/mm << " mm" << G4endl
      << "p.z() = "   << p.z()/mm << " mm" << G4endl
      << "DistanceToIn(p) == " << DistanceToIn(p);
    message.precision(oldprc) ;
    G4Exception("G4TriangularFacet::DistanceToOut(p)",
                "GeomSolids1002", JustWarning, message);
  }
#endif

  G4double minDist;

  if (OutsideOfExtent(p, kCarTolerance)) return 0.0;

  if (fVoxels.GetCountOfVoxels() > 1)
  {
    G4VFacet *facet;
    minDist = MinDistanceFacet(p, true, facet);
  }
  else
  {
    minDist = kInfinity;
    G4double dist = 0.0;
    G4int size = fFacets.size();
    for (G4int i = 0; i < size; ++i)
    {
      G4VFacet &facet = *fFacets[i];
      dist = facet.Distance(p,minDist);
      if (dist < minDist) minDist  = dist;
    }
  }
  return minDist;
}

G4double G4TessellatedSolid::SafetyFromOutside ( const G4ThreeVector &  p, G4bool  aAccurate = false  ) const

virtual

Definition at line 1474 of file G4TessellatedSolid.cc.

References G4VFacet::Distance(), G4SurfaceVoxelizer::DistanceToBoundingBox(), DistanceToOut(), G4Exception(), G4SurfaceVoxelizer::GetCandidates(), G4SurfaceVoxelizer::GetCountOfVoxels(), G4SurfBits::GetNbits(), G4SurfaceVoxelizer::GetPointIndex(), G4SurfaceVoxelizer::GetVoxel(), Inside(), JustWarning, G4VSolid::kCarTolerance, kInside, python.hepunit::mm, CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

Referenced by DistanceToIn().

{
#if G4SPECSDEBUG
  if ( Inside(p) == kInside )
  {
    std::ostringstream message;
    G4int oldprc = message.precision(16) ;
    message << "Point p is already inside!?" << G4endl
      << "Position:"  << G4endl << G4endl
      << "p.x() = "   << p.x()/mm << " mm" << G4endl
      << "p.y() = "   << p.y()/mm << " mm" << G4endl
      << "p.z() = "   << p.z()/mm << " mm" << G4endl
      << "DistanceToOut(p) == " << DistanceToOut(p);
    message.precision(oldprc) ;
    G4Exception("G4TriangularFacet::DistanceToIn(p)",
                "GeomSolids1002", JustWarning, message);
  }
#endif

  G4double minDist;

  if (fVoxels.GetCountOfVoxels() > 1)
  {
    if (!aAccurate)
      return fVoxels.DistanceToBoundingBox(p);

    if (!OutsideOfExtent(p, kCarTolerance))
    {
      vector<G4int> startingVoxel(3);
      fVoxels.GetVoxel(startingVoxel, p);
      const vector<G4int> &candidates = fVoxels.GetCandidates(startingVoxel);
      if (candidates.size() == 0 && fInsides.GetNbits())
      {
        G4int index = fVoxels.GetPointIndex(p);
        if (fInsides[index]) return 0.;
      }
    }

    G4VFacet *facet;
    minDist = MinDistanceFacet(p, true, facet);
  }
  else
  {
    minDist = kInfinity;
    G4int size = fFacets.size();
    for (G4int i = 0; i < size; ++i)
    {
      G4VFacet &facet = *fFacets[i];
      G4double dist = facet.Distance(p,minDist);
      if (dist < minDist) minDist  = dist;
    }
  }
  return minDist;
}

void G4TessellatedSolid::SetMaxVoxels ( G4int  max )

inline

Definition at line 307 of file G4TessellatedSolid.hh.

References G4SurfaceVoxelizer::SetMaxVoxels().

{
  fVoxels.SetMaxVoxels(max);
}

void G4TessellatedSolid::SetSolidClosed

(

const G4bool

t

)

Definition at line 578 of file G4TessellatedSolid.cc.

References DisplayAllocatedMemory(), G4cout, and G4endl.

Referenced by G4GDMLReadSolids::TessellatedRead().

{
  if (t)
  {
#ifdef G4SPECSDEBUG    
    G4cout << "Creating vertex list..." << G4endl;
#endif
    CreateVertexList();

#ifdef G4SPECSDEBUG    
    G4cout << "Setting extreme facets..." << G4endl;
#endif
    SetExtremeFacets();
    
#ifdef G4SPECSDEBUG    
    G4cout << "Voxelizing..." << G4endl;
#endif
    Voxelize();

#ifdef G4SPECSDEBUG
    DisplayAllocatedMemory();
#endif

  }  
  fSolidClosed = t;
}

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

virtual

Implements G4VSolid.

Reimplemented in G4ExtrudedSolid.

Definition at line 1589 of file G4TessellatedSolid.cc.

References G4endl, and G4VFacet::StreamInfo().

{
  os << G4endl;
  os << "Geometry Type    = " << fGeometryType  << G4endl;
  os << "Number of facets = " << fFacets.size() << G4endl;

  G4int size = fFacets.size();
  for (G4int i = 0; i < size; ++i)
  {
    os << "FACET #          = " << i + 1 << G4endl;
    G4VFacet &facet = *fFacets[i];
    facet.StreamInfo(os);
  }
  os << G4endl;

  return os;
}

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

virtual

Implements G4VSolid.

Definition at line 1643 of file G4TessellatedSolid.cc.

References n, and Normal().

Referenced by G4GenericTrap::SurfaceNormal().

{
  G4ThreeVector n;
  Normal(p, n);
  return n;
}

---

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

• G4TessellatedSolid.hh
• G4TessellatedSolid.cc