G4MultiUnion Class Reference

An instance of G4MultiUnion constitutes a grouping of several solids. The constituent solids are stored with their respective location in a node instance. An instance of G4MultiUnion is subsequently composed of one or several nodes. More...

#include <G4MultiUnion.hh>

Inheritance diagram for G4MultiUnion:

Public Member Functions
	G4MultiUnion ()
	G4MultiUnion (const G4String &name)
	~G4MultiUnion () override=default
	G4MultiUnion (__void__ &)
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 override
G4double	DistanceToIn (const G4ThreeVector &aPoint) const override
G4double	DistanceToOut (const G4ThreeVector &aPoint) const override
void	SetAccurateSafety (G4bool flag)
G4double	DistanceToIn (const G4ThreeVector &aPoint, const G4ThreeVector &aDirection) const override
G4double	DistanceToOut (const G4ThreeVector &aPoint, const G4ThreeVector &aDirection, const G4bool calcNorm=false, G4bool *validNorm=nullptr, G4ThreeVector *aNormalVector=nullptr) const override
G4double	DistanceToInNoVoxels (const G4ThreeVector &aPoint, const G4ThreeVector &aDirection) const
G4double	DistanceToOutVoxels (const G4ThreeVector &aPoint, const G4ThreeVector &aDirection, G4ThreeVector *aNormalVector) const
G4double	DistanceToOutNoVoxels (const G4ThreeVector &aPoint, const G4ThreeVector &aDirection, G4ThreeVector *aNormalVector) const
G4ThreeVector	SurfaceNormal (const G4ThreeVector &aPoint) const override
void	Extent (EAxis aAxis, G4double &aMin, G4double &aMax) const
void	BoundingLimits (G4ThreeVector &aMin, G4ThreeVector &aMax) const override
G4bool	CalculateExtent (const EAxis pAxis, const G4VoxelLimits &pVoxelLimit, const G4AffineTransform &pTransform, G4double &pMin, G4double &pMax) const override
G4double	GetCubicVolume () override
G4double	GetSurfaceArea () override
G4int	GetNumOfConstituents () const override
G4bool	IsFaceted () const override
G4VSolid *	Clone () const override
G4GeometryType	GetEntityType () const override
void	Voxelize ()
G4Voxelizer &	GetVoxels () const
std::ostream &	StreamInfo (std::ostream &os) const override
G4ThreeVector	GetPointOnSurface () const override
void	DescribeYourselfTo (G4VGraphicsScene &scene) const override
G4Polyhedron *	CreatePolyhedron () const override
G4Polyhedron *	GetPolyhedron () const override
Public Member Functions inherited from G4VSolid
	G4VSolid (const G4String &name)
virtual	~G4VSolid ()
	G4VSolid (const G4VSolid &rhs)
G4VSolid &	operator= (const G4VSolid &rhs)
G4bool	operator== (const G4VSolid &s) const
G4String	GetName () const
void	SetName (const G4String &name)
G4double	GetTolerance () const
virtual void	ComputeDimensions (G4VPVParameterisation *p, const G4int n, const G4VPhysicalVolume *pRep)
void	DumpInfo () const
virtual G4VisExtent	GetExtent () const
virtual const G4VSolid *	GetConstituentSolid (G4int no) const
virtual G4VSolid *	GetConstituentSolid (G4int no)
virtual const G4DisplacedSolid *	GetDisplacedSolidPtr () const
virtual G4DisplacedSolid *	GetDisplacedSolidPtr ()
	G4VSolid (__void__ &)
G4double	EstimateCubicVolume (G4int nStat, G4double epsilon) const
G4double	EstimateSurfaceArea (G4int nStat, G4double epsilon) const

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

An instance of G4MultiUnion constitutes a grouping of several solids. The constituent solids are stored with their respective location in a node instance. An instance of G4MultiUnion is subsequently composed of one or several nodes.

Definition at line 61 of file G4MultiUnion.hh.

Constructor & Destructor Documentation

G4MultiUnion() [1/4]

G4MultiUnion::G4MultiUnion

(

)

Empty default constructor.

Definition at line 57 of file G4MultiUnion.cc.

  : G4VSolid("")
{
}

Referenced by Clone(), G4MultiUnion(), operator=(), and ~G4MultiUnion().

G4MultiUnion() [2/4]

G4MultiUnion::G4MultiUnion

(

const G4String &

name

)

Constructor assigning a name and initialising components.

Definition at line 63 of file G4MultiUnion.cc.

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

~G4MultiUnion()

G4MultiUnion::~G4MultiUnion ( )

overridedefault

Default destructor.

G4MultiUnion() [3/4]

G4MultiUnion::G4MultiUnion

(

__void__ &

a

)

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

Definition at line 103 of file G4MultiUnion.cc.

  : G4VSolid(a)
{
}

G4MultiUnion() [4/4]

G4MultiUnion::G4MultiUnion

(

const G4MultiUnion &

rhs

)

Copy constructor and assignment operator.

Definition at line 94 of file G4MultiUnion.cc.

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

Member Function Documentation

AddNode() [1/2]

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

Methods to build the multiple union by adding nodes (by pointer or ref).

Parameters

[in]	solid	The solid to be added to the structure.
[in]	trans	The 3D transformation relative to the structure.

Definition at line 73 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 80 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

overridevirtual

Computes the bounding limits of the solid.

Parameters

[out]	aMin	The minimum bounding limit point.
[out]	aMax	The maximum bounding limit point.

Reimplemented from G4VSolid.

Definition at line 583 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().

CalculateExtent()

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

overridevirtual

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

Parameters

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

Returns

True if the solid is intersected by the extent region.

Implements G4VSolid.

Definition at line 593 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

overridevirtual

Returns a new allocated clone of the multi-union structure.

Reimplemented from G4VSolid.

Definition at line 87 of file G4MultiUnion.cc.

{
  return new G4MultiUnion(*this);
}

CreatePolyhedron()

G4Polyhedron * G4MultiUnion::CreatePolyhedron ( ) const

overridevirtual

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

Reimplemented from G4VSolid.

Definition at line 969 of file G4MultiUnion.cc.

{
  if (G4BooleanSolid::GetExternalBooleanProcessor() == nullptr)
  {
    HepPolyhedronProcessor processor;
    HepPolyhedronProcessor::Operation operation = HepPolyhedronProcessor::UNION;
 
    G4VSolid* solidA = GetSolid(0);
    const G4Transform3D transform0 = GetTransformation(0);
    G4DisplacedSolid dispSolidA("placedA", solidA, transform0);
 
    auto 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;
    }
    return nullptr;
  }
  else
  {
    return G4BooleanSolid::GetExternalBooleanProcessor()->Process(this);
  }
}

Referenced by GetPolyhedron().

DescribeYourselfTo()

void G4MultiUnion::DescribeYourselfTo ( G4VGraphicsScene & scene ) const

overridevirtual

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

Implements G4VSolid.

Definition at line 963 of file G4MultiUnion.cc.

{
  scene.AddSolid (*this);
}

DistanceToIn() [1/2]

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

overridevirtual

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

Parameters

[in]

p

The point at offset p.

Returns

The safety distance to enter the shape.

Implements G4VSolid.

Definition at line 723 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

overridevirtual

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

Implements G4VSolid.

Definition at line 187 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 != 0.0) { currentPoint += direction * shift; }
 
  G4SurfBits exclusion(fVoxels.GetBitsPerSlice());
  std::vector<G4int> candidates, curVoxel(3);
  fVoxels.GetVoxel(curVoxel, currentPoint);
 
  do
  {
    {
      if (fVoxels.GetCandidatesVoxelArray(curVoxel, candidates, &exclusion) != 0)
      {
        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

Methods to compute the distance to enter/exit a volume, given point and direction, in presence of voxels-based optimisation structure or not.

Definition at line 128 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 & p ) const

overridevirtual

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

Parameters

[in]

p

The point at offset p.

Returns

The safety distance to exit the shape.

Implements G4VSolid.

Definition at line 686 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

overridevirtual

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. The normal vector to the crossed surface is always filled. In the case the considered point is located inside the G4MultiUnion structure, it acts as follows:

• investigation of the candidates for the passed point
• progressive moving of the point towards the surface, along the provided direction
• processing of the normal.

  Parameters

  [in]	aPoint	The reference point in space.
  [in]	aDirection	The normalised direction.
  [in]	calcNorm	Flag unused.
  [out]	validNorm	Unused.
  [out]	aNormalVector	The exiting outwards normal vector (undefined Magnitude).

  Returns

  The distance value to exit a volume.

Implements G4VSolid.

Definition at line 272 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 221 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;
 
  auto 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,
                                                false, nullptr, 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 282 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) != 0)
  {
    // 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, nullptr, &localNormal);
          if (maxDistance < shift)
          {
            maxDistance = shift;
            maxCandidate = candidate;
            maxNormal = localNormal;
          }
        }
      }
 
      if (notOutside)
      {
        const G4Transform3D& transform = fTransformObjs[maxCandidate];
 
        // convert from local normal
        if (aNormal != nullptr)
        {
          *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().

Extent()

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

Determines the bounding box for the considered instance of G4MultiUnion.

Parameters

[in]	aAxis	The axis along which computing the extent.
[out]	aMin	The minimum bounding limit point.
[out]	aMax	The maximum bounding limit point.

Definition at line 523 of file G4MultiUnion.cc.

{
  // Determines the bounding box for the considered instance of G4MultiUnion
 
  G4ThreeVector min, max;
 
  auto 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 ( )

overridevirtual

Returns an estimate of the structure capacity or surface area.

Reimplemented from G4VSolid.

Definition at line 938 of file G4MultiUnion.cc.

{
  if (fCubicVolume == 0)
  {
    G4AutoLock l(&munionMutex);
    fCubicVolume = EstimateCubicVolume(1000000, 0.001);
    l.unlock();
  }
  return fCubicVolume;
}

GetEntityType()

G4GeometryType G4MultiUnion::GetEntityType ( ) const

inlineoverridevirtual

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

Implements G4VSolid.

Definition at line 231 of file G4MultiUnion.hh.

{ return "G4MultiUnion"; }

GetNumberOfSolids()

G4int G4MultiUnion::GetNumberOfSolids ( ) const

inline

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

GetNumOfConstituents()

G4int G4MultiUnion::GetNumOfConstituents ( ) const

overridevirtual

Returns the number of solids part of the structure.

Reimplemented from G4VSolid.

Definition at line 780 of file G4MultiUnion.cc.

{
  G4int num = 0;
  for (const auto solid : fSolids)
  {
    num += solid->GetNumOfConstituents();
  }
  return num;
}

GetPointOnSurface()

G4ThreeVector G4MultiUnion::GetPointOnSurface ( ) const

overridevirtual

Returns a point (G4ThreeVector) randomly and uniformly generated on the surface of a solid.

Reimplemented from G4VSolid.

Definition at line 921 of file G4MultiUnion.cc.

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

GetPolyhedron()

G4Polyhedron * G4MultiUnion::GetPolyhedron ( ) const

overridevirtual

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

Reimplemented from G4VSolid.

Definition at line 1004 of file G4MultiUnion.cc.

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

GetSolid()

G4VSolid * G4MultiUnion::GetSolid ( G4int index ) const

inline

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

GetSurfaceArea()

G4double G4MultiUnion::GetSurfaceArea ( )

overridevirtual

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

Reimplemented from G4VSolid.

Definition at line 950 of file G4MultiUnion.cc.

{
  if (fSurfaceArea == 0)
  {
    G4AutoLock l(&munionMutex);
    fSurfaceArea = EstimateSurfaceArea(1000000, -1.);
    l.unlock();
  }
  return fSurfaceArea;
}

GetTransformation()

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

inline

Accessors to retrieve a transformation or a solid, given an index and the total number of solids in the structure.

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

GetVoxels()

G4Voxelizer & G4MultiUnion::GetVoxels ( ) const

inline

Returns the xoxelised optimisation structure.

Inside()

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

overridevirtual

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

Implements G4VSolid.

Definition at line 490 of file G4MultiUnion.cc.

{
  return InsideWithExclusion(aPoint);
}

Referenced by GetPointOnSurface().

IsFaceted()

G4bool G4MultiUnion::IsFaceted ( ) const

overridevirtual

Returns false if any of the solids part of the structure is not faceted.

Reimplemented from G4VSolid.

Definition at line 791 of file G4MultiUnion.cc.

{
  for (const auto solid : fSolids)
  {
    if (!solid->IsFaceted()) { return false; }
  }
  return true;
}

operator=()

G4MultiUnion & G4MultiUnion::operator=

(

const G4MultiUnion &

rhs

)

Definition at line 110 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

StreamInfo()

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

overridevirtual

Streams the object contents to an output stream.

Implements G4VSolid.

Definition at line 895 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

overridevirtual

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

Implements G4VSolid.

Definition at line 609 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) != 0)
  {
    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();
      }
      
      // 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();
  }
  
  // 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

(

)

Finalises and prepares for use, creating the optimisation structure for all solids in the structure. It must be called once before navigation use.

Definition at line 801 of file G4MultiUnion.cc.

{
  fVoxels.Voxelize(fSolids, fTransformObjs);
}

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

Friends And Related Symbol Documentation

G4Voxelizer

friend class G4Voxelizer

friend

Definition at line 63 of file G4MultiUnion.hh.

Referenced by G4Voxelizer, and GetVoxels().

---

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

• G4MultiUnion.hh
• G4MultiUnion.cc