G4MultiUnion Class Reference

#include <G4MultiUnion.hh>

Inheritance diagram for G4MultiUnion:

Public Member Functions
	G4MultiUnion ()
	G4MultiUnion (const G4String &name)
	~G4MultiUnion ()
void	AddNode (G4VSolid &solid, const G4Transform3D &trans)
void	AddNode (G4VSolid *solid, const G4Transform3D &trans)
	G4MultiUnion (const G4MultiUnion &rhs)
G4MultiUnion &	operator= (const G4MultiUnion &rhs)
const G4Transform3D &	GetTransformation (G4int index) const
G4VSolid *	GetSolid (G4int index) const
G4int	GetNumberOfSolids () const
EInside	Inside (const G4ThreeVector &aPoint) const
EInside	InsideIterator (const G4ThreeVector &aPoint) const
G4double	DistanceToIn (const G4ThreeVector &aPoint) const
G4double	DistanceToOut (const G4ThreeVector &aPoint) const
void	SetAccurateSafety (G4bool flag)
G4double	DistanceToIn (const G4ThreeVector &aPoint, const G4ThreeVector &aDirection) const
G4double	DistanceToOut (const G4ThreeVector &aPoint, const G4ThreeVector &aDirection, const G4bool calcNorm=false, G4bool *validNorm=nullptr, G4ThreeVector *aNormalVector=nullptr) const
G4double	DistanceToInNoVoxels (const G4ThreeVector &aPoint, const G4ThreeVector &aDirection) const
G4double	DistanceToOutVoxels (const G4ThreeVector &aPoint, const G4ThreeVector &aDirection, G4ThreeVector *aNormalVector) const
G4double	DistanceToOutVoxelsCore (const G4ThreeVector &aPoint, const G4ThreeVector &aDirection, G4ThreeVector *aNormalVector, G4bool &aConvex, std::vector< G4int > &candidates) const
G4double	DistanceToOutNoVoxels (const G4ThreeVector &aPoint, const G4ThreeVector &aDirection, G4ThreeVector *aNormalVector) const
G4ThreeVector	SurfaceNormal (const G4ThreeVector &aPoint) const
void	Extent (EAxis aAxis, G4double &aMin, G4double &aMax) const
void	BoundingLimits (G4ThreeVector &aMin, G4ThreeVector &aMax) const
G4bool	CalculateExtent (const EAxis pAxis, const G4VoxelLimits &pVoxelLimit, const G4AffineTransform &pTransform, G4double &pMin, G4double &pMax) const
G4double	GetCubicVolume ()
G4double	GetSurfaceArea ()
G4VSolid *	Clone () const
G4GeometryType	GetEntityType () const
void	Voxelize ()
EInside	InsideNoVoxels (const G4ThreeVector &aPoint) const
G4Voxelizer &	GetVoxels () const
std::ostream &	StreamInfo (std::ostream &os) const
G4ThreeVector	GetPointOnSurface () const
void	DescribeYourselfTo (G4VGraphicsScene &scene) const
G4Polyhedron *	CreatePolyhedron () const
G4Polyhedron *	GetPolyhedron () const
	G4MultiUnion (__void__ &)
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	BoundingLimits (G4ThreeVector &pMin, G4ThreeVector &pMax) const
virtual G4bool	CalculateExtent (const EAxis pAxis, const G4VoxelLimits &pVoxelLimit, const G4AffineTransform &pTransform, G4double &pMin, G4double &pMax) const =0
virtual EInside	Inside (const G4ThreeVector &p) const =0
virtual G4ThreeVector	SurfaceNormal (const G4ThreeVector &p) const =0
virtual G4double	DistanceToIn (const G4ThreeVector &p, const G4ThreeVector &v) const =0
virtual G4double	DistanceToIn (const G4ThreeVector &p) const =0
virtual G4double	DistanceToOut (const G4ThreeVector &p, const G4ThreeVector &v, const G4bool calcNorm=false, G4bool *validNorm=nullptr, G4ThreeVector *n=nullptr) const =0
virtual G4double	DistanceToOut (const G4ThreeVector &p) const =0
virtual void	ComputeDimensions (G4VPVParameterisation *p, const G4int n, const G4VPhysicalVolume *pRep)
virtual G4double	GetCubicVolume ()
virtual G4double	GetSurfaceArea ()
virtual G4GeometryType	GetEntityType () const =0
virtual G4ThreeVector	GetPointOnSurface () const
virtual G4VSolid *	Clone () const
virtual std::ostream &	StreamInfo (std::ostream &os) const =0
void	DumpInfo () const
virtual void	DescribeYourselfTo (G4VGraphicsScene &scene) const =0
virtual G4VisExtent	GetExtent () const
virtual G4Polyhedron *	CreatePolyhedron () const
virtual G4Polyhedron *	GetPolyhedron () 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)
G4double	EstimateCubicVolume (G4int nStat, G4double epsilon) const
G4double	EstimateSurfaceArea (G4int nStat, G4double ell) const

Friends
class	G4Voxelizer

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

Detailed Description

Definition at line 53 of file G4MultiUnion.hh.

Constructor & Destructor Documentation

G4MultiUnion() [1/4]

G4MultiUnion::G4MultiUnion ( )

inline

Definition at line 59 of file G4MultiUnion.hh.

: G4VSolid("") {}

Referenced by Clone().

G4MultiUnion() [2/4]

G4MultiUnion::G4MultiUnion

(

const G4String &

name

)

Definition at line 54 of file G4MultiUnion.cc.

  : G4VSolid(name)
{
  SetName(name);
  fSolids.clear();
  fTransformObjs.clear();
  kRadTolerance = G4GeometryTolerance::GetInstance()->GetRadialTolerance();
}

~G4MultiUnion()

G4MultiUnion::~G4MultiUnion

(

)

Definition at line 64 of file G4MultiUnion.cc.

{
}

G4MultiUnion() [3/4]

G4MultiUnion::G4MultiUnion

(

const G4MultiUnion &

rhs

)

Definition at line 90 of file G4MultiUnion.cc.

  : G4VSolid(rhs), fCubicVolume(rhs.fCubicVolume),
    fSurfaceArea(rhs.fSurfaceArea),
    kRadTolerance(rhs.kRadTolerance), fAccurate(rhs.fAccurate)
{
}

G4MultiUnion() [4/4]

G4MultiUnion::G4MultiUnion

(

__void__ &

a

)

Definition at line 99 of file G4MultiUnion.cc.

  : G4VSolid(a)
{
}

Member Function Documentation

AddNode() [1/2]

void G4MultiUnion::AddNode	(	G4VSolid &	solid,
		const G4Transform3D &	trans
	)

Definition at line 69 of file G4MultiUnion.cc.

{
  fSolids.push_back(&solid);
  fTransformObjs.push_back(trans);  // Store a local copy of transformations
}

Referenced by G4tgbVolume::FindOrConstructG4Solid(), and G4GDMLReadSolids::MultiUnionNodeRead().

AddNode() [2/2]

void G4MultiUnion::AddNode	(	G4VSolid *	solid,
		const G4Transform3D &	trans
	)

Definition at line 76 of file G4MultiUnion.cc.

{
  fSolids.push_back(solid);
  fTransformObjs.push_back(trans);  // Store a local copy of transformations
}

BoundingLimits()

void G4MultiUnion::BoundingLimits ( G4ThreeVector &  aMin, G4ThreeVector &  aMax  ) const

virtual

Reimplemented from G4VSolid.

Definition at line 620 of file G4MultiUnion.cc.

{
   Extent(kXAxis, aMin[0], aMax[0]);
   Extent(kYAxis, aMin[1], aMax[1]);
   Extent(kZAxis, aMin[2], aMax[2]);
}

Referenced by CalculateExtent(), and GetCubicVolume().

CalculateExtent()

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

virtual

Implements G4VSolid.

Definition at line 630 of file G4MultiUnion.cc.

{
  G4ThreeVector bmin, bmax;
 
  // Get bounding box
  BoundingLimits(bmin,bmax);
 
  // Find extent
  G4BoundingEnvelope bbox(bmin,bmax);
  return bbox.CalculateExtent(pAxis,pVoxelLimit,pTransform,pMin,pMax);
}

Clone()

G4VSolid * G4MultiUnion::Clone ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 83 of file G4MultiUnion.cc.

{
  return new G4MultiUnion(*this);
}

CreatePolyhedron()

G4Polyhedron * G4MultiUnion::CreatePolyhedron ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 972 of file G4MultiUnion.cc.

{
  HepPolyhedronProcessor processor;
  HepPolyhedronProcessor::Operation operation = HepPolyhedronProcessor::UNION;
 
  G4VSolid* solidA = GetSolid(0);
  const G4Transform3D transform0=GetTransformation(0);
  G4DisplacedSolid dispSolidA("placedA",solidA,transform0);
 
  G4Polyhedron* top = new G4Polyhedron(*dispSolidA.GetPolyhedron());
    
  for(G4int i=1; i<GetNumberOfSolids(); ++i)
  {
    G4VSolid* solidB = GetSolid(i);
    const G4Transform3D transform=GetTransformation(i);
    G4DisplacedSolid dispSolidB("placedB",solidB,transform);
    G4Polyhedron* operand = dispSolidB.GetPolyhedron();
    processor.push_back (operation, *operand);
  }
   
  if (processor.execute(*top)) { return top; }
  else { return 0; } 
}

Referenced by GetPolyhedron().

DescribeYourselfTo()

void G4MultiUnion::DescribeYourselfTo ( G4VGraphicsScene &  scene ) const

virtual

Implements G4VSolid.

Definition at line 966 of file G4MultiUnion.cc.

{
  scene.AddSolid (*this);
}

DistanceToIn() [1/2]

G4double G4MultiUnion::DistanceToIn ( const G4ThreeVector &  aPoint ) const

virtual

Implements G4VSolid.

Definition at line 764 of file G4MultiUnion.cc.

{
  // Estimates the isotropic safety from a point outside the current solid to
  // any of its surfaces. The algorithm may be accurate or should provide a fast
  // underestimate.
 
  if (!fAccurate)  { return fVoxels.DistanceToBoundingBox(point); }
 
  const std::vector<G4VoxelBox>& boxes = fVoxels.GetBoxes();
  G4double safetyMin = kInfinity;
  G4ThreeVector localPoint;
 
  std::size_t numNodes = fSolids.size();
  for (std::size_t j = 0; j < numNodes; ++j)
  {
    G4ThreeVector dxyz;
    if (j > 0)
    {
      const G4ThreeVector& pos = boxes[j].pos;
      const G4ThreeVector& hlen = boxes[j].hlen;
      for (auto i = 0; i <= 2; ++i)
        // distance to middle point - hlength => distance from point to border
        // of x,y,z
        if ((dxyz[i] = std::abs(point[i] - pos[i]) - hlen[i]) > safetyMin)
          continue;
 
      G4double d2xyz = 0.;
      for (auto i = 0; i <= 2; ++i)
        if (dxyz[i] > 0) d2xyz += dxyz[i] * dxyz[i];
 
      // minimal distance is at least this, but could be even higher. therefore,
      // we can stop if previous was already lower, let us check if it does any
      // chance to be better tha previous values...
      if (d2xyz >= safetyMin * safetyMin)
      {
        continue;
      }
    }
    const G4Transform3D& transform = fTransformObjs[j];
    localPoint = GetLocalPoint(transform, point);
    G4VSolid& solid = *fSolids[j];
 
    G4double safety = solid.DistanceToIn(localPoint);
    if (safety <= 0) return safety;
      // it was detected, that the point is not located outside
    if (safetyMin > safety) safetyMin = safety;
  }
  return safetyMin;
}

DistanceToIn() [2/2]

G4double G4MultiUnion::DistanceToIn ( const G4ThreeVector &  aPoint, const G4ThreeVector &  aDirection  ) const

virtual

Implements G4VSolid.

Definition at line 212 of file G4MultiUnion.cc.

{
  G4double minDistance = kInfinity;
  G4ThreeVector direction = aDirection.unit();
  G4double shift = fVoxels.DistanceToFirst(aPoint, direction);
  if (shift == kInfinity) return shift;
 
  G4ThreeVector currentPoint = aPoint;
  if (shift) currentPoint += direction * shift;
 
  G4SurfBits exclusion(fVoxels.GetBitsPerSlice());
  std::vector<G4int> candidates, curVoxel(3);
  fVoxels.GetVoxel(curVoxel, currentPoint);
 
  do
  {
    {
      if (fVoxels.GetCandidatesVoxelArray(curVoxel, candidates, &exclusion))
      {
        G4double distance = DistanceToInCandidates(aPoint, direction,
                                                   candidates, exclusion);
        if (minDistance > distance) minDistance = distance;
        if (distance < shift) break;
      }
    }
    shift = fVoxels.DistanceToNext(aPoint, direction, curVoxel);
  }
  while (minDistance > shift);
 
  return minDistance;
}

DistanceToInNoVoxels()

G4double G4MultiUnion::DistanceToInNoVoxels	(	const G4ThreeVector &	aPoint,
		const G4ThreeVector &	aDirection
	)		const

Definition at line 153 of file G4MultiUnion.cc.

{
  G4ThreeVector direction = aDirection.unit();
  G4ThreeVector localPoint, localDirection;
  G4double minDistance = kInfinity;
 
  std::size_t numNodes = fSolids.size();
  for (std::size_t i = 0 ; i < numNodes ; ++i)
  {
    G4VSolid& solid = *fSolids[i];
    const G4Transform3D& transform = fTransformObjs[i];
 
    localPoint = GetLocalPoint(transform, aPoint);
    localDirection = GetLocalVector(transform, direction);
 
    G4double distance = solid.DistanceToIn(localPoint, localDirection);
    if (minDistance > distance) minDistance = distance;
  }
  return minDistance;
}

DistanceToOut() [1/2]

G4double G4MultiUnion::DistanceToOut ( const G4ThreeVector &  aPoint ) const

virtual

Implements G4VSolid.

Definition at line 727 of file G4MultiUnion.cc.

{
  // Estimates isotropic distance to the surface of the solid. This must
  // be either accurate or an underestimate.
  // Two modes: - default/fast mode, sacrificing accuracy for speed
  //            - "precise" mode,  requests accurate value if available.
 
  std::vector<G4int> candidates;
  G4ThreeVector localPoint;
  G4double safetyMin = kInfinity;
 
  // In general, the value return by DistanceToIn(p) will not be the exact
  // but only an undervalue (cf. overlaps)
  fVoxels.GetCandidatesVoxelArray(point, candidates);
 
  std::size_t limit = candidates.size();
  for (std::size_t i = 0; i < limit; ++i)
  {
    G4int candidate = candidates[i];
 
    // The coordinates of the point are modified so as to fit the intrinsic
    // solid local frame:
    const G4Transform3D& transform = fTransformObjs[candidate];
    localPoint = GetLocalPoint(transform, point);
    G4VSolid& solid = *fSolids[candidate];
    if (solid.Inside(localPoint) == EInside::kInside)
    {
      G4double safety = solid.DistanceToOut(localPoint);
      if (safetyMin > safety) safetyMin = safety;
    }
  }
  if (safetyMin == kInfinity) safetyMin = 0; // we are not inside
 
  return safetyMin;
}

DistanceToOut() [2/2]

G4double G4MultiUnion::DistanceToOut ( const G4ThreeVector &  aPoint, const G4ThreeVector &  aDirection, const G4bool  calcNorm = false, G4bool *  validNorm = nullptr, G4ThreeVector *  aNormalVector = nullptr  ) const

virtual

Implements G4VSolid.

Definition at line 297 of file G4MultiUnion.cc.

{
  return DistanceToOutVoxels(aPoint, aDirection, aNormal);
}

DistanceToOutNoVoxels()

G4double G4MultiUnion::DistanceToOutNoVoxels	(	const G4ThreeVector &	aPoint,
		const G4ThreeVector &	aDirection,
		G4ThreeVector *	aNormalVector
	)		const

Definition at line 246 of file G4MultiUnion.cc.

{
  // Computes distance from a point presumably outside the solid to the solid
  // surface. Ignores first surface if the point is actually inside.
  // Early return infinity in case the safety to any surface is found greater
  // than the proposed step aPstep.
  // The normal vector to the crossed surface is filled only in case the box
  // is crossed, otherwise aNormal->IsNull() is true.
 
  // algorithm:
  G4ThreeVector direction = aDirection.unit();
  G4ThreeVector localPoint, localDirection;
  G4int ignoredSolid = -1;
  G4double resultDistToOut = 0;
  G4ThreeVector currentPoint = aPoint;
 
  G4int numNodes = (G4int)fSolids.size();
  for (auto i = 0; i < numNodes; ++i)
  {
    if (i != ignoredSolid)
    {
      G4VSolid& solid = *fSolids[i];
      const G4Transform3D& transform = fTransformObjs[i];
      localPoint = GetLocalPoint(transform, currentPoint);
      localDirection = GetLocalVector(transform, direction);
      EInside location = solid.Inside(localPoint);
      if (location != EInside::kOutside)
      {
        G4double distance = solid.DistanceToOut(localPoint, localDirection,
                                                aNormal);
        if (distance < kInfinity)
        {
          if (resultDistToOut == kInfinity) resultDistToOut = 0;
          if (distance > 0)
          {
            currentPoint = GetGlobalPoint(transform, localPoint
                                          + distance*localDirection);
            resultDistToOut += distance;
            ignoredSolid = i; // skip the solid which we have just left
            i = -1; // force the loop to continue from 0
          }
        }
      }
    }
  }
  return resultDistToOut;
}

DistanceToOutVoxels()

G4double G4MultiUnion::DistanceToOutVoxels	(	const G4ThreeVector &	aPoint,
		const G4ThreeVector &	aDirection,
		G4ThreeVector *	aNormalVector
	)		const

Definition at line 307 of file G4MultiUnion.cc.

{
  // Computes distance from a point presumably inside the solid to the solid
  // surface. Ignores first surface along each axis systematically (for points
  // inside or outside. Early returns zero in case the second surface is behind
  // the starting point.
  // o The proposed step is ignored.
  // o The normal vector to the crossed surface is always filled.
 
  // In the case the considered point is located inside the G4MultiUnion
  // structure, the treatments are as follows:
  //      - investigation of the candidates for the passed point
  //      - progressive moving of the point towards the surface, along the
  //        passed direction
  //      - processing of the normal
 
  G4ThreeVector direction = aDirection.unit();
  std::vector<G4int> candidates;
  G4double distance = 0;
  std::size_t numNodes = 2*fSolids.size();
  std::size_t count=0;
 
  if (fVoxels.GetCandidatesVoxelArray(aPoint, candidates))
  {
    // For normal case for which we presume the point is inside
    G4ThreeVector localPoint, localDirection, localNormal;
    G4ThreeVector currentPoint = aPoint;
    G4SurfBits exclusion(fVoxels.GetBitsPerSlice());
    G4bool notOutside;
    G4ThreeVector maxNormal;
 
    do
    {
      notOutside = false;
 
      G4double maxDistance = -kInfinity;
      G4int maxCandidate = 0;
      G4ThreeVector maxLocalPoint;
 
      std::size_t limit = candidates.size();
      for (std::size_t i = 0 ; i < limit ; ++i)
      {
        G4int candidate = candidates[i];
        // ignore the current component (that you just got out of) since
        // numerically the propagated point will be on its surface
 
        G4VSolid& solid = *fSolids[candidate];
        const G4Transform3D& transform = fTransformObjs[candidate];
 
        // The coordinates of the point are modified so as to fit the
        // intrinsic solid local frame:
        localPoint = GetLocalPoint(transform, currentPoint);
 
        // DistanceToOut at least for Trd sometimes return non-zero value
        // even from points that are outside. Therefore, this condition
        // must currently be here, otherwise it would not work.
        // But it means it would be slower.
 
        if (solid.Inside(localPoint) != EInside::kOutside)
        {
          notOutside = true;
 
          localDirection = GetLocalVector(transform, direction);
 
          // propagate with solid.DistanceToOut
          G4double shift = solid.DistanceToOut(localPoint, localDirection,
                                               false, 0, &localNormal);
          if (maxDistance < shift)
          {
            maxDistance = shift;
            maxCandidate = candidate;
            maxNormal = localNormal;
          }
        }
      }
 
      if (notOutside)
      {
        const G4Transform3D& transform = fTransformObjs[maxCandidate];
 
        // convert from local normal
        if (aNormal) *aNormal = GetGlobalVector(transform, maxNormal);
 
        distance += maxDistance;
        currentPoint += maxDistance * direction;
        if(maxDistance == 0.) ++count;
 
        // the current component will be ignored
        exclusion.SetBitNumber(maxCandidate);
        EInside location = InsideWithExclusion(currentPoint, &exclusion);
 
        // perform a Inside
        // it should be excluded current solid from checking
        // we have to collect the maximum distance from all given candidates.
        // such "maximum" candidate should be then used for finding next
        // candidates
        if (location == EInside::kOutside)
        {
          // else return cumulated distances to outside of the traversed
          // components
          break;
        }
        // if inside another component, redo 1 to 3 but add the next
        // DistanceToOut on top of the previous.
 
        // and fill the candidates for the corresponding voxel (just
        // exiting current component along direction)
        candidates.clear();
 
        fVoxels.GetCandidatesVoxelArray(currentPoint, candidates, &exclusion);
        exclusion.ResetBitNumber(maxCandidate);
      }
    }
    while  ((notOutside) && (count < numNodes));
  }
 
  return distance;
}

Referenced by DistanceToOut().

DistanceToOutVoxelsCore()

G4double G4MultiUnion::DistanceToOutVoxelsCore	(	const G4ThreeVector &	aPoint,
		const G4ThreeVector &	aDirection,
		G4ThreeVector *	aNormalVector,
		G4bool &	aConvex,
		std::vector< G4int > &	candidates
	)		const

Extent()

void G4MultiUnion::Extent	(	EAxis	aAxis,
		G4double &	aMin,
		G4double &	aMax
	)		const

Definition at line 555 of file G4MultiUnion.cc.

{
  // Determines the bounding box for the considered instance of "UMultipleUnion"
  G4ThreeVector min, max;
 
  G4int numNodes = (G4int)fSolids.size();
  for (auto i = 0 ; i < numNodes ; ++i)
  {
    G4VSolid& solid = *fSolids[i];
    G4Transform3D transform = GetTransformation(i);
    solid.BoundingLimits(min, max);
   
    TransformLimits(min, max, transform);
    
    if (i == 0)
    {
      switch (aAxis)
      {
        case kXAxis:
          aMin = min.x();
          aMax = max.x();
          break;
        case kYAxis:
          aMin = min.y();
          aMax = max.y();
          break;
        case kZAxis:
          aMin = min.z();
          aMax = max.z();
          break;
        default:
          break;
      }
    }
    else
    {
      // Determine the min/max on the considered axis:
      switch (aAxis)
      {
        case kXAxis:
          if (min.x() < aMin)
            aMin = min.x();
          if (max.x() > aMax)
            aMax = max.x();
          break;
        case kYAxis:
          if (min.y() < aMin)
            aMin = min.y();
          if (max.y() > aMax)
            aMax = max.y();
          break;
        case kZAxis:
          if (min.z() < aMin)
            aMin = min.z();
          if (max.z() > aMax)
            aMax = max.z();
          break;
        default:
          break;
      }
    }
  }
}

Referenced by BoundingLimits().

GetCubicVolume()

G4double G4MultiUnion::GetCubicVolume ( )

virtual

Reimplemented from G4VSolid.

Definition at line 123 of file G4MultiUnion.cc.

{
  // Computes the cubic volume of the "G4MultiUnion" structure using
  // random points
 
  if (!fCubicVolume)
  {
    G4ThreeVector extentMin, extentMax, d, p, point;
    G4int inside = 0, generated;
    BoundingLimits(extentMin, extentMax);
    d = (extentMax - extentMin) / 2.;
    p = (extentMax + extentMin) / 2.;
    G4ThreeVector left = p - d;
    G4ThreeVector length = d * 2;
    for (generated = 0; generated < 10000; ++generated)
    {
      G4ThreeVector rvec(G4UniformRand(), G4UniformRand(), G4UniformRand());
      point = left + G4ThreeVector(length.x()*rvec.x(),
                                   length.y()*rvec.y(),
                                   length.z()*rvec.z());
      if (Inside(point) != EInside::kOutside) ++inside;
    }
    G4double vbox = (2 * d.x()) * (2 * d.y()) * (2 * d.z());
    fCubicVolume = inside * vbox / generated;
  }
  return fCubicVolume;
}

GetEntityType()

G4GeometryType G4MultiUnion::GetEntityType ( ) const

inlinevirtual

Implements G4VSolid.

Definition at line 121 of file G4MultiUnion.hh.

{ return "G4MultiUnion"; }

GetNumberOfSolids()

G4int G4MultiUnion::GetNumberOfSolids ( ) const

inline

Definition at line 204 of file G4MultiUnion.hh.

{
  return G4int(fSolids.size());
}

Referenced by CreatePolyhedron(), G4tgbGeometryDumper::DumpMultiUnionVolume(), and G4GDMLWriteSolids::MultiUnionWrite().

GetPointOnSurface()

G4ThreeVector G4MultiUnion::GetPointOnSurface ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 945 of file G4MultiUnion.cc.

{
  G4ThreeVector point;
 
  G4long size = fSolids.size();
 
  do
  {
    G4long rnd = G4RandFlat::shootInt(G4long(0), size);
    G4VSolid& solid = *fSolids[rnd];
    point = solid.GetPointOnSurface();
    const G4Transform3D& transform = fTransformObjs[rnd];
    point = GetGlobalPoint(transform, point);
  }
  while (Inside(point) != EInside::kSurface);
 
  return point;
}

GetPolyhedron()

G4Polyhedron * G4MultiUnion::GetPolyhedron ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 997 of file G4MultiUnion.cc.

{
  if (fpPolyhedron == nullptr ||
      fRebuildPolyhedron ||
      fpPolyhedron->GetNumberOfRotationStepsAtTimeOfCreation() !=
      fpPolyhedron->GetNumberOfRotationSteps())
    {
      G4AutoLock l(&polyhedronMutex);
      delete fpPolyhedron;
      fpPolyhedron = CreatePolyhedron();
      fRebuildPolyhedron = false;
      l.unlock();
    }
  return fpPolyhedron;
}

GetSolid()

G4VSolid * G4MultiUnion::GetSolid ( G4int  index ) const

inline

Definition at line 198 of file G4MultiUnion.hh.

{
  return fSolids[index];
}

Referenced by CreatePolyhedron(), G4tgbGeometryDumper::DumpMultiUnionVolume(), and G4GDMLWriteSolids::MultiUnionWrite().

GetSurfaceArea()

G4double G4MultiUnion::GetSurfaceArea ( )

virtual

Reimplemented from G4VSolid.

Definition at line 815 of file G4MultiUnion.cc.

{
  if (!fSurfaceArea)
  {
    fSurfaceArea = EstimateSurfaceArea(1000000, 0.001);
  }
  return fSurfaceArea;
}

GetTransformation()

const G4Transform3D & G4MultiUnion::GetTransformation ( G4int  index ) const

inline

Definition at line 192 of file G4MultiUnion.hh.

{
  return fTransformObjs[index];
}

Referenced by CreatePolyhedron(), G4tgbGeometryDumper::DumpMultiUnionVolume(), Extent(), InsideNoVoxels(), and G4GDMLWriteSolids::MultiUnionWrite().

GetVoxels()

G4Voxelizer & G4MultiUnion::GetVoxels ( ) const

inline

Definition at line 186 of file G4MultiUnion.hh.

{
  return (G4Voxelizer&)fVoxels;
}

Inside()

EInside G4MultiUnion::Inside ( const G4ThreeVector &  aPoint ) const

virtual

Implements G4VSolid.

Definition at line 507 of file G4MultiUnion.cc.

{
  // Classify point location with respect to solid:
  //  o eInside       - inside the solid
  //  o eSurface      - close to surface within tolerance
  //  o eOutside      - outside the solid
 
  // Hitherto, it is considered that only parallelepipedic nodes can be
  // added to the container
 
  // Implementation using voxelisation techniques:
  // ---------------------------------------------
 
  //  return InsideIterator(aPoint);
 
  EInside location = InsideWithExclusion(aPoint);
  return location;
}

Referenced by GetCubicVolume(), and GetPointOnSurface().

InsideIterator()

EInside G4MultiUnion::InsideIterator

(

const G4ThreeVector &

aPoint

)

const

InsideNoVoxels()

EInside G4MultiUnion::InsideNoVoxels

(

const G4ThreeVector &

aPoint

)

const

Definition at line 527 of file G4MultiUnion.cc.

{
  G4ThreeVector localPoint;
  EInside location = EInside::kOutside;
  G4int countSurface = 0;
 
  G4int numNodes = (G4int)fSolids.size();
  for (auto i = 0 ; i < numNodes ; ++i)
  {
    G4VSolid& solid = *fSolids[i];
    G4Transform3D transform = GetTransformation(i);
 
    // The coordinates of the point are modified so as to fit the
    // intrinsic solid local frame:
    localPoint = GetLocalPoint(transform, aPoint);
 
    location = solid.Inside(localPoint);
 
    if (location == EInside::kSurface)
      ++countSurface;
 
    if (location == EInside::kInside) return EInside::kInside;
  }
  if (countSurface != 0) return EInside::kSurface;
  return EInside::kOutside;
}

operator=()

G4MultiUnion & G4MultiUnion::operator=

(

const G4MultiUnion &

rhs

)

Definition at line 106 of file G4MultiUnion.cc.

{
  // Check assignment to self
  //
  if (this == &rhs)
  {
    return *this;
  }
 
  // Copy base class data
  //
  G4VSolid::operator=(rhs);
 
  return *this;
}

SetAccurateSafety()

void G4MultiUnion::SetAccurateSafety ( G4bool  flag )

inline

Definition at line 210 of file G4MultiUnion.hh.

{
  fAccurate = flag;
}

StreamInfo()

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

virtual

Implements G4VSolid.

Definition at line 919 of file G4MultiUnion.cc.

{
  G4long oldprc = os.precision(16);
  os << "-----------------------------------------------------------\n"
     << "                *** Dump for solid - " << GetName() << " ***\n"
     << "                ===================================================\n"
     << " Solid type: G4MultiUnion\n"
     << " Parameters: \n";
     std::size_t numNodes = fSolids.size();
     for (std::size_t i = 0 ; i < numNodes ; ++i)
     {
      G4VSolid& solid = *fSolids[i];
      solid.StreamInfo(os);
      const G4Transform3D& transform = fTransformObjs[i];
      os << " Translation is " << transform.getTranslation() << " \n";
      os << " Rotation is :" << " \n";
      os << " " << transform.getRotation() << "\n";
     }
  os << "             \n"
     << "-----------------------------------------------------------\n";
  os.precision(oldprc);
 
  return os;
}

SurfaceNormal()

G4ThreeVector G4MultiUnion::SurfaceNormal ( const G4ThreeVector &  aPoint ) const

virtual

Implements G4VSolid.

Definition at line 646 of file G4MultiUnion.cc.

{
  // Computes the localNormal on a surface and returns it as a unit vector.
  // Must return a valid vector. (even if the point is not on the surface).
  //
  //   On an edge or corner, provide an average localNormal of all facets within
  //   tolerance
  //   NOTE: the tolerance value used in here is not yet the global surface
  //         tolerance - we will have to revise this value - TODO
 
  std::vector<G4int> candidates;
  G4ThreeVector localPoint, normal, localNormal;
  G4double safety = kInfinity;
  G4int node = 0;
 
  ///////////////////////////////////////////////////////////////////////////
  // Important comment: Cases for which the point is located on an edge or
  // on a vertice remain to be treated
 
  // determine weather we are in voxel area
  if (fVoxels.GetCandidatesVoxelArray(aPoint, candidates))
  {
    std::size_t limit = candidates.size();
    for (std::size_t i = 0 ; i < limit ; ++i)
    {
      G4int candidate = candidates[i];
      const G4Transform3D& transform = fTransformObjs[candidate];
 
      // The coordinates of the point are modified so as to fit the intrinsic
      // solid local frame:
      localPoint = GetLocalPoint(transform, aPoint);
      G4VSolid& solid = *fSolids[candidate];
      EInside location = solid.Inside(localPoint);
 
      if (location == EInside::kSurface)
      {
        // normal case when point is on surface, we pick first solid
        normal = GetGlobalVector(transform, solid.SurfaceNormal(localPoint));
        return normal.unit();
      }
      else
      {
        // collect the smallest safety and remember solid node
        G4double s = (location == EInside::kInside)
                   ? solid.DistanceToOut(localPoint)
                   : solid.DistanceToIn(localPoint);
        if (s < safety)
        {
          safety = s;
          node = candidate;
        }
      }
    }
    // on none of the solids, the point was not on the surface
    G4VSolid& solid = *fSolids[node];
    const G4Transform3D& transform = fTransformObjs[node];
    localPoint = GetLocalPoint(transform, aPoint);
 
    normal = GetGlobalVector(transform, solid.SurfaceNormal(localPoint));
    return normal.unit();
  }
  else
  {
    // for the case when point is certainly outside:
 
    // find a solid in union with the smallest safety
    node = SafetyFromOutsideNumberNode(aPoint, safety);
    G4VSolid& solid = *fSolids[node];
 
    const G4Transform3D& transform = fTransformObjs[node];
    localPoint = GetLocalPoint(transform, aPoint);
 
    // evaluate normal for point at this found solid
    // and transform multi-union coordinates
    normal = GetGlobalVector(transform, solid.SurfaceNormal(localPoint));
 
    return normal.unit();
  }
}

Voxelize()

void G4MultiUnion::Voxelize

(

)

Definition at line 825 of file G4MultiUnion.cc.

{
  fVoxels.Voxelize(fSolids, fTransformObjs);
}

Referenced by G4tgbVolume::FindOrConstructG4Solid(), and G4GDMLReadSolids::MultiUnionRead().

Friends And Related Function Documentation

G4Voxelizer

friend class G4Voxelizer

friend

Definition at line 55 of file G4MultiUnion.hh.

---

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

• G4MultiUnion.hh
• G4MultiUnion.cc