#include <G4ReduciblePolygon.hh>

Data Structures
struct	ABVertex

Public Member Functions
G4double	Amax () const

G4double	Amin () const

G4double	Area ()

G4bool	BisectedBy (G4double a1, G4double b1, G4double a2, G4double b2, G4double tolerance)

G4double	Bmax () const

G4double	Bmin () const

void	CopyVertices (G4double a[], G4double b[]) const

G4bool	CrossesItself (G4double tolerance)

	G4ReduciblePolygon (__void__ &)

	G4ReduciblePolygon (const G4double a[], const G4double b[], G4int n)

	G4ReduciblePolygon (const G4double rmin[], const G4double rmax[], const G4double z[], G4int n)

G4int	NumVertices () const

void	Print ()

G4bool	RemoveDuplicateVertices (G4double tolerance)

G4bool	RemoveRedundantVertices (G4double tolerance)

void	ReverseOrder ()

void	ScaleA (G4double scale)

void	ScaleB (G4double scale)

void	StartWithZMin ()

virtual	~G4ReduciblePolygon ()

Protected Member Functions
void	CalculateMaxMin ()

void	Create (const G4double a[], const G4double b[], G4int n)

Protected Attributes
G4double	aMax

G4double	aMin

G4double	bMax

G4double	bMin

G4int	numVertices = 0

ABVertex *	vertexHead = nullptr

Private Member Functions
	G4ReduciblePolygon (const G4ReduciblePolygon &)

G4ReduciblePolygon &	operator= (const G4ReduciblePolygon &)

Friends
struct	ABVertex

class	G4ReduciblePolygonIterator

Detailed Description

Definition at line 52 of file G4ReduciblePolygon.hh.

Constructor & Destructor Documentation

◆ G4ReduciblePolygon() [1/4]

G4ReduciblePolygon::G4ReduciblePolygon	(	const G4double	a[],
		const G4double	b[],
		G4int	n
	)

Definition at line 38 of file G4ReduciblePolygon.cc.

  : aMin(0.), aMax(0.), bMin(0.), bMax(0.)
{
  //
  // Do all of the real work in Create
  //
  Create( a, b, n );
}

References Create(), and CLHEP::detail::n.

◆ G4ReduciblePolygon() [2/4]

G4ReduciblePolygon::G4ReduciblePolygon	(	const G4double	rmin[],
		const G4double	rmax[],
		const G4double	z[],
		G4int	n
	)

Definition at line 51 of file G4ReduciblePolygon.cc.

  : aMin(0.), aMax(0.), bMin(0.), bMax(0.)
{
  //
  // Translate
  //
  G4double *a = new G4double[n*2];
  G4double *b = new G4double[n*2];
  
  G4double *rOut = a + n,
           *zOut = b + n,
            *rIn = rOut-1,
            *zIn = zOut-1;
  
  for( G4int i=0; i < n; ++i, ++rOut, ++zOut, --rIn, --zIn )
  {
    *rOut = rmax[i];
    *rIn  = rmin[i];
    *zOut = *zIn = z[i];
  }
  
  Create( a, b, n*2 );
  
  delete [] a;
  delete [] b;
}

References Create(), and CLHEP::detail::n.

◆ ~G4ReduciblePolygon()

G4ReduciblePolygon::~G4ReduciblePolygon ( )

virtual

Definition at line 129 of file G4ReduciblePolygon.cc.

{
  ABVertex* curr = vertexHead;
  while( curr != nullptr )    // Loop checking, 13.08.2015, G.Cosmo
  {
    ABVertex* toDelete = curr;
    curr = curr->next;
    delete toDelete;
  }
}

References G4ReduciblePolygon::ABVertex::next, and vertexHead.

◆ G4ReduciblePolygon() [3/4]

G4ReduciblePolygon::G4ReduciblePolygon ( __void__ & )

Definition at line 120 of file G4ReduciblePolygon.cc.

  : aMin(0.), aMax(0.), bMin(0.), bMax(0.)
{
}

◆ G4ReduciblePolygon() [4/4]

G4ReduciblePolygon::G4ReduciblePolygon ( const G4ReduciblePolygon & )

private

Member Function Documentation

◆ Amax()

G4double G4ReduciblePolygon::Amax ( ) const

inline

Definition at line 78 of file G4ReduciblePolygon.hh.

78{ return aMax; }

References aMax.

Referenced by G4EnclosingCylinder::G4EnclosingCylinder(), and G4PolyPhiFace::G4PolyPhiFace().

◆ Amin()

G4double G4ReduciblePolygon::Amin ( ) const

inline

Definition at line 77 of file G4ReduciblePolygon.hh.

77{ return aMin; }

References aMin.

Referenced by G4Polyhedra::Create(), G4GenericPolycone::Create(), G4Polycone::Create(), and G4PolyPhiFace::G4PolyPhiFace().

◆ Area()

G4double G4ReduciblePolygon::Area ( )

Definition at line 519 of file G4ReduciblePolygon.cc.

{
  G4double answer = 0;
  
  ABVertex *curr = vertexHead, *next = nullptr;
  do    // Loop checking, 13.08.2015, G.Cosmo
  {
    next = curr->next;
    if (next==0) next = vertexHead;
    
    answer += curr->a*next->b - curr->b*next->a;
    curr = curr->next;
  } while( curr != nullptr );
  
  return 0.5*answer;
}

References G4ReduciblePolygon::ABVertex::a, G4ReduciblePolygon::ABVertex::b, G4ReduciblePolygon::ABVertex::next, and vertexHead.

Referenced by G4Polyhedra::Create(), G4GenericPolycone::Create(), and G4Polycone::Create().

◆ BisectedBy()

G4bool G4ReduciblePolygon::BisectedBy	(	G4double	a1,
		G4double	b1,
		G4double	a2,
		G4double	b2,
		G4double	tolerance
	)

Definition at line 477 of file G4ReduciblePolygon.cc.

{
  G4int nNeg = 0, nPos = 0;
  
  G4double a12 = a2-a1, b12 = b2-b1;
  G4double len12 = std::sqrt( a12*a12 + b12*b12 );
  a12 /= len12; b12 /= len12;
  
  ABVertex* curr = vertexHead;
  do    // Loop checking, 13.08.2015, G.Cosmo
  {
    G4double av = curr->a - a1,
             bv = curr->b - b1;
       
    G4double cross = av*b12 - bv*a12;
    
    if (cross < -tolerance)
    {
      if (nPos) return true;
      ++nNeg;
    }
    else if (cross > tolerance)
    {
      if (nNeg) return true;
      ++nPos;
    }
    curr = curr->next;
  } while( curr != nullptr );
    
  return false;
}

References G4ReduciblePolygon::ABVertex::a, G4ReduciblePolygon::ABVertex::b, G4ReduciblePolygon::ABVertex::next, and vertexHead.

Referenced by G4GenericPolycone::Create(), and G4Polycone::Create().

◆ Bmax()

G4double G4ReduciblePolygon::Bmax ( ) const

inline

Definition at line 80 of file G4ReduciblePolygon.hh.

80{ return bMax; }

References bMax.

Referenced by G4EnclosingCylinder::G4EnclosingCylinder(), G4PolyPhiFace::G4PolyPhiFace(), G4Polycone::SetOriginalParameters(), and G4Polyhedra::SetOriginalParameters().

◆ Bmin()

G4double G4ReduciblePolygon::Bmin ( ) const

inline

Definition at line 79 of file G4ReduciblePolygon.hh.

79{ return bMin; }

References bMin.

Referenced by G4EnclosingCylinder::G4EnclosingCylinder(), and G4PolyPhiFace::G4PolyPhiFace().

◆ CalculateMaxMin()

void G4ReduciblePolygon::CalculateMaxMin ( )

protected

Definition at line 553 of file G4ReduciblePolygon.cc.

{
  ABVertex* curr = vertexHead;
  aMin = aMax = curr->a;
  bMin = bMax = curr->b;
  curr = curr->next;
  while( curr != nullptr )    // Loop checking, 13.08.2015, G.Cosmo
  {
    if (curr->a < aMin)
      aMin = curr->a;
    else if (curr->a > aMax)
      aMax = curr->a;
 
    if (curr->b < bMin)
      bMin = curr->b;
    else if (curr->b > bMax)
      bMax = curr->b;
    
    curr = curr->next;
  }
}

References G4ReduciblePolygon::ABVertex::a, aMax, aMin, G4ReduciblePolygon::ABVertex::b, bMax, bMin, G4ReduciblePolygon::ABVertex::next, and vertexHead.

Referenced by Create(), RemoveDuplicateVertices(), and RemoveRedundantVertices().

◆ CopyVertices()

void G4ReduciblePolygon::CopyVertices	(	G4double	a[],
		G4double	b[]
	)		const

Definition at line 146 of file G4ReduciblePolygon.cc.

{
  G4double *anext = a, *bnext = b;
  ABVertex *curr = vertexHead;
  while( curr != nullptr )    // Loop checking, 13.08.2015, G.Cosmo
  {
    *anext++ = curr->a;
    *bnext++ = curr->b;
    curr = curr->next;
  }
}

References G4ReduciblePolygon::ABVertex::a, G4ReduciblePolygon::ABVertex::b, G4ReduciblePolygon::ABVertex::next, and vertexHead.

◆ Create()

void G4ReduciblePolygon::Create	(	const G4double	a[],
		const G4double	b[],
		G4int	n
	)

protected

Definition at line 85 of file G4ReduciblePolygon.cc.

{
  if (n<3)
   G4Exception("G4ReduciblePolygon::Create()", "GeomSolids0002",
               FatalErrorInArgument, "Less than 3 vertices specified.");
  
  const G4double *anext = a, *bnext = b;
  ABVertex* prev = nullptr;
  do    // Loop checking, 13.08.2015, G.Cosmo
  {
    ABVertex *newVertex = new ABVertex;
    newVertex->a = *anext;
    newVertex->b = *bnext;
    newVertex->next = nullptr;
    if (prev==nullptr)
    {
      vertexHead = newVertex;
    }
    else
    {
      prev->next = newVertex;
    }
      
    prev = newVertex;
  } while( ++anext, ++bnext < b+n );
 
  numVertices = n;
  
  CalculateMaxMin();
}

References G4ReduciblePolygon::ABVertex::a, ABVertex, G4ReduciblePolygon::ABVertex::b, CalculateMaxMin(), FatalErrorInArgument, G4Exception(), CLHEP::detail::n, G4ReduciblePolygon::ABVertex::next, numVertices, and vertexHead.

Referenced by G4ReduciblePolygon().

◆ CrossesItself()

G4bool G4ReduciblePolygon::CrossesItself ( G4double tolerance )

Definition at line 422 of file G4ReduciblePolygon.cc.

{
  G4double tolerance2 = tolerance*tolerance;
  G4double one  = 1.0-tolerance,
           zero = tolerance;
  //
  // Top loop over line segments. By the time we finish
  // with the second to last segment, we're done.
  //
  ABVertex *curr1 = vertexHead, *next1 = nullptr;
  while (curr1->next != nullptr)    // Loop checking, 13.08.2015, G.Cosmo
  {
    next1 = curr1->next;
    G4double da1 = next1->a-curr1->a,
             db1 = next1->b-curr1->b;
    
    //
    // Inner loop over subsequent line segments
    //
    ABVertex* curr2 = next1->next;
    while( curr2 != nullptr )    // Loop checking, 13.08.2015, G.Cosmo
    {
      ABVertex* next2 = curr2->next;
      if (next2==nullptr) next2 = vertexHead;
      G4double da2 = next2->a-curr2->a,
               db2 = next2->b-curr2->b;
      G4double a12 = curr2->a-curr1->a,
               b12 = curr2->b-curr1->b;
         
      //
      // Calculate intersection of the two lines
      //
      G4double deter = da1*db2 - db1*da2;
      if (std::fabs(deter) > tolerance2)
      {
        G4double s1, s2;
        s1 = (a12*db2-b12*da2)/deter;
        
        if (s1 >= zero && s1 < one)
        {
          s2 = -(da1*b12-db1*a12)/deter;
          if (s2 >= zero && s2 < one) return true;
        }
      }
      curr2 = curr2->next;   
    }
    curr1 = next1;
  }
  return false;
}

References G4ReduciblePolygon::ABVertex::a, G4ReduciblePolygon::ABVertex::b, G4ReduciblePolygon::ABVertex::next, vertexHead, and anonymous_namespace{G4CascadeDeexciteBase.cc}::zero.

Referenced by G4Polyhedra::Create(), G4GenericPolycone::Create(), and G4Polycone::Create().

◆ NumVertices()

G4int G4ReduciblePolygon::NumVertices ( ) const

inline

Definition at line 75 of file G4ReduciblePolygon.hh.

75{ return numVertices; }

References numVertices.

Referenced by G4Polyhedra::Create(), G4GenericPolycone::Create(), G4Polycone::Create(), and G4PolyPhiFace::G4PolyPhiFace().

◆ operator=()

G4ReduciblePolygon & G4ReduciblePolygon::operator= ( const G4ReduciblePolygon & )

private

◆ Print()

void G4ReduciblePolygon::Print ( )

Definition at line 538 of file G4ReduciblePolygon.cc.

{
  ABVertex* curr = vertexHead;
  do    // Loop checking, 13.08.2015, G.Cosmo
  {
    G4cerr << curr->a << " " << curr->b << G4endl;
    curr = curr->next;
  } while( curr != nullptr );
}

References G4ReduciblePolygon::ABVertex::a, G4ReduciblePolygon::ABVertex::b, G4cerr, G4endl, G4ReduciblePolygon::ABVertex::next, and vertexHead.

◆ RemoveDuplicateVertices()

G4bool G4ReduciblePolygon::RemoveDuplicateVertices ( G4double tolerance )

Definition at line 191 of file G4ReduciblePolygon.cc.

{
  ABVertex *curr = vertexHead, 
           *prev = nullptr, *next = nullptr;
  while( curr != nullptr )    // Loop checking, 13.08.2015, G.Cosmo
  {
    next = curr->next;
    if (next == nullptr) next = vertexHead;
    
    if (std::fabs(curr->a-next->a) < tolerance &&
        std::fabs(curr->b-next->b) < tolerance     )
    {
      //
      // Duplicate found: do we have > 3 vertices?
      //
      if (numVertices <= 3)
      {
        CalculateMaxMin();
        return false;
      }
      
      //
      // Delete
      //
      ABVertex* toDelete = curr;
      curr = curr->next;
      delete toDelete;
      
      numVertices--;
      
      if (prev != nullptr)
        prev->next = curr;
      else 
        vertexHead = curr;
    }
    else
    {
      prev = curr;
      curr = curr->next;
    }
  }
  
  //
  // In principle, this is not needed, but why not just play it safe?
  //
  CalculateMaxMin();
  
  return true;
}

References G4ReduciblePolygon::ABVertex::a, G4ReduciblePolygon::ABVertex::b, CalculateMaxMin(), G4ReduciblePolygon::ABVertex::next, numVertices, and vertexHead.

Referenced by G4Polyhedra::Create(), G4GenericPolycone::Create(), and G4Polycone::Create().

◆ RemoveRedundantVertices()

G4bool G4ReduciblePolygon::RemoveRedundantVertices ( G4double tolerance )

Definition at line 246 of file G4ReduciblePolygon.cc.

{
  //
  // Under these circumstances, we can quit now!
  //
  if (numVertices <= 2) return false;
  
  G4double tolerance2 = tolerance*tolerance;
 
  //
  // Loop over all vertices
  //
  ABVertex *curr = vertexHead, *next = nullptr;
  while( curr != nullptr )    // Loop checking, 13.08.2015, G.Cosmo
  {
    next = curr->next;
    if (next == nullptr) next = vertexHead;
    
    G4double da = next->a - curr->a,
             db = next->b - curr->b;
    
    //
    // Loop over all subsequent vertices, up to curr
    //
    for(;;)
    {
      //
      // Get vertex after next
      //
      ABVertex* test = next->next;
      if (test == nullptr) test = vertexHead;
      
      //
      // If we are back to the original vertex, stop
      //
      if (test==curr) break;
    
      //
      // Test for parallel line segments
      //
      G4double dat = test->a - curr->a,
               dbt = test->b - curr->b;
         
      if (std::fabs(dat*db-dbt*da)>tolerance2) break;
      
      //
      // Redundant vertex found: do we have > 3 vertices?
      // 
      if (numVertices <= 3)
      {
        CalculateMaxMin();
        return false;
      }
 
      //
      // Delete vertex pointed to by next. Carefully!
      //
      if (curr->next != nullptr)
      {    // next is not head
        if (next->next != nullptr)
          curr->next = test;  // next is not tail
        else
          curr->next = nullptr;    // New tail
      }
      else
        vertexHead = test;  // New head
        
      if ((curr != next) && (next != test)) delete next;
      
      --numVertices;
      
      //
      // Replace next by the vertex we just tested,
      // and keep on going...
      //
      next = test;
      da = dat; db = dbt;
    }
    curr = curr->next;
  }
  
  //
  // In principle, this is not needed, but why not just play it safe?
  //
  CalculateMaxMin();
  
  return true;
}

References G4ReduciblePolygon::ABVertex::a, G4ReduciblePolygon::ABVertex::b, CalculateMaxMin(), G4ReduciblePolygon::ABVertex::next, numVertices, mcscore::test(), and vertexHead.

Referenced by G4Polyhedra::Create(), G4GenericPolycone::Create(), and G4Polycone::Create().

◆ ReverseOrder()

void G4ReduciblePolygon::ReverseOrder ( )

Definition at line 339 of file G4ReduciblePolygon.cc.

{
  //
  // Loop over all vertices
  //
  ABVertex* prev = vertexHead;
  if (prev==nullptr) return;    // No vertices
  
  ABVertex* curr = prev->next;
  if (curr==nullptr) return;    // Just one vertex
  
  //
  // Our new tail
  //
  vertexHead->next = nullptr;
  
  for(;;)
  {
    //
    // Save pointer to next vertex (in original order)
    //
    ABVertex *save = curr->next;
    
    //
    // Replace it with a pointer to the previous one
    // (in original order)
    //
    curr->next = prev;
    
    //
    // Last vertex?
    //
    if (save == nullptr) break;
    
    //
    // Next vertex
    //
    prev = curr;
    curr = save;
  }
  
  //
  // Our new head
  //
  vertexHead = curr;
}

References G4ReduciblePolygon::ABVertex::next, and vertexHead.

Referenced by G4Polyhedra::Create(), G4GenericPolycone::Create(), and G4Polycone::Create().

◆ ScaleA()

void G4ReduciblePolygon::ScaleA ( G4double scale )

Definition at line 162 of file G4ReduciblePolygon.cc.

{
  ABVertex* curr = vertexHead;
  while( curr != nullptr )    // Loop checking, 13.08.2015, G.Cosmo
  {
    curr->a *= scale;
    curr = curr->next;
  }
}  

References G4ReduciblePolygon::ABVertex::a, G4ReduciblePolygon::ABVertex::next, and vertexHead.

Referenced by G4Polyhedra::G4Polyhedra().

◆ ScaleB()

void G4ReduciblePolygon::ScaleB ( G4double scale )

Definition at line 176 of file G4ReduciblePolygon.cc.

{
  ABVertex* curr = vertexHead;
  while( curr != nullptr )    // Loop checking, 13.08.2015, G.Cosmo
  {
    curr->b *= scale;
    curr = curr->next;
  }
}  

References G4ReduciblePolygon::ABVertex::b, G4ReduciblePolygon::ABVertex::next, and vertexHead.

◆ StartWithZMin()

void G4ReduciblePolygon::StartWithZMin ( )

Definition at line 392 of file G4ReduciblePolygon.cc.

{ 
  ABVertex* curr = vertexHead;
  G4double bcurr = curr->b;
  ABVertex* prev = curr;
  while( curr != nullptr)    // Loop checking, 13.08.2015, G.Cosmo
  { 
    if(curr->b < bcurr)
    { 
      bcurr = curr->b;
      ABVertex* curr1 = curr;   
      while( curr1 != nullptr )    // Loop checking, 13.08.2015, G.Cosmo
      {
        if(curr1->next == nullptr) { curr1->next = vertexHead; break; }
        curr1 = curr1->next;
      }
      vertexHead = curr;         
      prev->next = nullptr;
    }
    prev = curr;
    curr = curr->next;
  }
}

References G4ReduciblePolygon::ABVertex::b, G4ReduciblePolygon::ABVertex::next, and vertexHead.

Referenced by G4Polycone::SetOriginalParameters(), and G4Polyhedra::SetOriginalParameters().

Friends And Related Function Documentation

◆ ABVertex

friend struct ABVertex

friend

Definition at line 132 of file G4ReduciblePolygon.hh.

Referenced by Create().

◆ G4ReduciblePolygonIterator

friend class G4ReduciblePolygonIterator

friend

Definition at line 54 of file G4ReduciblePolygon.hh.

Field Documentation

◆ aMax

G4double G4ReduciblePolygon::aMax

protected

Definition at line 122 of file G4ReduciblePolygon.hh.

Referenced by Amax(), and CalculateMaxMin().

◆ aMin

G4double G4ReduciblePolygon::aMin

protected

Definition at line 122 of file G4ReduciblePolygon.hh.

Referenced by Amin(), and CalculateMaxMin().

◆ bMax

G4double G4ReduciblePolygon::bMax

protected

Definition at line 122 of file G4ReduciblePolygon.hh.

Referenced by Bmax(), and CalculateMaxMin().

◆ bMin

G4double G4ReduciblePolygon::bMin

protected

Definition at line 122 of file G4ReduciblePolygon.hh.

Referenced by Bmin(), and CalculateMaxMin().

◆ numVertices

G4int G4ReduciblePolygon::numVertices = 0

protected

Definition at line 123 of file G4ReduciblePolygon.hh.

Referenced by Create(), NumVertices(), RemoveDuplicateVertices(), and RemoveRedundantVertices().

◆ vertexHead

ABVertex* G4ReduciblePolygon::vertexHead = nullptr

protected

Definition at line 140 of file G4ReduciblePolygon.hh.

Referenced by Area(), G4ReduciblePolygonIterator::Begin(), BisectedBy(), CalculateMaxMin(), CopyVertices(), Create(), CrossesItself(), Print(), RemoveDuplicateVertices(), RemoveRedundantVertices(), ReverseOrder(), ScaleA(), ScaleB(), StartWithZMin(), and ~G4ReduciblePolygon().

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

source/geometry/solids/specific/include/G4ReduciblePolygon.hh
source/geometry/solids/specific/src/G4ReduciblePolygon.cc

Data Structures

Public Member Functions

Protected Member Functions

Protected Attributes

Private Member Functions

Friends

Detailed Description

Constructor & Destructor Documentation

◆ G4ReduciblePolygon() [1/4]

◆ G4ReduciblePolygon() [2/4]

◆ ~G4ReduciblePolygon()

◆ G4ReduciblePolygon() [3/4]

◆ G4ReduciblePolygon() [4/4]

Member Function Documentation

◆ Amax()

◆ Amin()

◆ Area()

◆ BisectedBy()

◆ Bmax()

◆ Bmin()

◆ CalculateMaxMin()

◆ CopyVertices()

◆ Create()

◆ CrossesItself()

◆ NumVertices()

◆ operator=()

◆ Print()

◆ RemoveDuplicateVertices()

◆ RemoveRedundantVertices()

◆ ReverseOrder()

◆ ScaleA()

◆ ScaleB()

◆ StartWithZMin()

Friends And Related Function Documentation

◆ ABVertex

◆ G4ReduciblePolygonIterator

Field Documentation

◆ aMax

◆ aMin

◆ bMax

◆ bMin

◆ numVertices

◆ vertexHead