#include <G4ReduciblePolygon.hh>

Classes
struct	ABVertex

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

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

virtual	~G4ReduciblePolygon ()

G4int	NumVertices () const

G4double	Amin () const

G4double	Amax () const

G4double	Bmin () const

G4double	Bmax () const

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

void	ScaleA (G4double scale)

void	ScaleB (G4double scale)

G4bool	RemoveDuplicateVertices (G4double tolerance)

G4bool	RemoveRedundantVertices (G4double tolerance)

void	ReverseOrder ()

G4double	Area ()

G4bool	CrossesItself (G4double tolerance)

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

void	Print ()

	G4ReduciblePolygon (__void__ &)

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

void	CalculateMaxMin ()

Protected Attributes
G4double	aMin

G4double	aMax

G4double	bMin

G4double	bMax

G4int	numVertices

ABVertex *	vertexHead

Friends
class	G4ReduciblePolygonIterator

struct	ABVertex

Detailed Description

Definition at line 61 of file G4ReduciblePolygon.hh.

Constructor & Destructor Documentation

◆ G4ReduciblePolygon() [1/3]

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

Definition at line 49 of file G4ReduciblePolygon.cc.

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

◆ G4ReduciblePolygon() [2/3]

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

Definition at line 65 of file G4ReduciblePolygon.cc.

  : aMin(0.), aMax(0.), bMin(0.), bMax(0.),
    vertexHead(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;
  
  G4int i;   
  for( 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;
}

◆ ~G4ReduciblePolygon()

G4ReduciblePolygon::~G4ReduciblePolygon ( )

virtual

Definition at line 149 of file G4ReduciblePolygon.cc.

{
  ABVertex *curr = vertexHead;
  while( curr )
  {
    ABVertex *toDelete = curr;
    curr = curr->next;
    delete toDelete;
  }
}

◆ G4ReduciblePolygon() [3/3]

G4ReduciblePolygon::G4ReduciblePolygon ( __void__ & )

Definition at line 140 of file G4ReduciblePolygon.cc.

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

Member Function Documentation

◆ Amax()

G4double G4ReduciblePolygon::Amax ( ) const

inline

Definition at line 87 of file G4ReduciblePolygon.hh.

87{ return aMax; }

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

◆ Amin()

G4double G4ReduciblePolygon::Amin ( ) const

inline

Definition at line 86 of file G4ReduciblePolygon.hh.

86{ return aMin; }

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

◆ Area()

G4double G4ReduciblePolygon::Area ( )

Definition at line 526 of file G4ReduciblePolygon.cc.

{
  G4double answer = 0;
  
  ABVertex *curr = vertexHead, *next;
  do
  {
    next = curr->next;
    if (next==0) next = vertexHead;
    
    answer += curr->a*next->b - curr->b*next->a;
    curr = curr->next;
  } while( curr );
  
  return 0.5*answer;
}

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

◆ BisectedBy()

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

Definition at line 481 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
  {
    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 );
    
  return false;
}

Referenced by G4Polycone::Create().

◆ Bmax()

G4double G4ReduciblePolygon::Bmax ( ) const

inline

Definition at line 89 of file G4ReduciblePolygon.hh.

89{ return bMax; }

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

◆ Bmin()

G4double G4ReduciblePolygon::Bmin ( ) const

inline

Definition at line 88 of file G4ReduciblePolygon.hh.

88{ return bMin; }

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

◆ CalculateMaxMin()

void G4ReduciblePolygon::CalculateMaxMin ( )

protected

Definition at line 564 of file G4ReduciblePolygon.cc.

{
  ABVertex *curr = vertexHead;
  aMin = aMax = curr->a;
  bMin = bMax = curr->b;
  curr = curr->next;
  while( curr )
  {
    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;
  }
}

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

◆ CopyVertices()

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

Definition at line 168 of file G4ReduciblePolygon.cc.

{
  G4double *anext = a, *bnext = b;
  ABVertex *curr = vertexHead;
  while( curr )
  {
    *anext++ = curr->a;
    *bnext++ = curr->b;
    curr = curr->next;
  }
}

◆ Create()

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

protected

Definition at line 103 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 = 0;
  do
  {
    ABVertex *newVertex = new ABVertex;
    newVertex->a = *anext;
    newVertex->b = *bnext;
    newVertex->next = 0;
    if (prev==0)
    {
      vertexHead = newVertex;
    }
    else
    {
      prev->next = newVertex;
    }
      
    prev = newVertex;
  } while( ++anext, ++bnext < b+n );
 
  numVertices = n;
  
  CalculateMaxMin();
}

Referenced by G4ReduciblePolygon().

◆ CrossesItself()

G4bool G4ReduciblePolygon::CrossesItself ( G4double tolerance )

Definition at line 423 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=0;
  while (curr1->next)
  {
    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 )
    {
      ABVertex *next2 = curr2->next;
      if (next2==0) 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;
}

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

◆ NumVertices()

G4int G4ReduciblePolygon::NumVertices ( ) const

inline

Definition at line 84 of file G4ReduciblePolygon.hh.

84{ return numVertices; }

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

◆ Print()

void G4ReduciblePolygon::Print ( )

Definition at line 547 of file G4ReduciblePolygon.cc.

{
  ABVertex *curr = vertexHead;
  do
  {
    G4cerr << curr->a << " " << curr->b << G4endl;
    curr = curr->next;
  } while( curr );
}

◆ RemoveDuplicateVertices()

G4bool G4ReduciblePolygon::RemoveDuplicateVertices ( G4double tolerance )

Definition at line 219 of file G4ReduciblePolygon.cc.

{
  ABVertex *curr = vertexHead, 
           *prev = 0, *next = 0;
  while( curr )
  {
    next = curr->next;
    if (next == 0) 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) 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;
}

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

◆ RemoveRedundantVertices()

G4bool G4ReduciblePolygon::RemoveRedundantVertices ( G4double tolerance )

Definition at line 273 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 = 0;
  while( curr )
  {
    next = curr->next;
    if (next == 0) 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 == 0) 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)
      {    // next is not head
        if (next->next)
          curr->next = test;  // next is not tail
        else
          curr->next = 0;    // 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;
}

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

◆ ReverseOrder()

void G4ReduciblePolygon::ReverseOrder ( )

Definition at line 368 of file G4ReduciblePolygon.cc.

{
  //
  // Loop over all vertices
  //
  ABVertex *prev = vertexHead;
  if (prev==0) return;    // No vertices
  
  ABVertex *curr = prev->next;
  if (curr==0) return;    // Just one vertex
  
  //
  // Our new tail
  //
  vertexHead->next = 0;
  
  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 == 0) break;
    
    //
    // Next vertex
    //
    prev = curr;
    curr = save;
  }
  
  //
  // Our new head
  //
  vertexHead = curr;
}

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

◆ ScaleA()

void G4ReduciblePolygon::ScaleA ( G4double scale )

Definition at line 186 of file G4ReduciblePolygon.cc.

{
  ABVertex *curr = vertexHead;
  while( curr )
  {
    curr->a *= scale;
    curr = curr->next;
  }
}  

Referenced by G4Polyhedra::G4Polyhedra().

◆ ScaleB()

void G4ReduciblePolygon::ScaleB ( G4double scale )

Definition at line 202 of file G4ReduciblePolygon.cc.

{
  ABVertex *curr = vertexHead;
  while( curr )
  {
    curr->b *= scale;
    curr = curr->next;
  }
}  

Friends And Related Function Documentation

◆ ABVertex

friend struct ABVertex

friend

Definition at line 140 of file G4ReduciblePolygon.hh.

◆ G4ReduciblePolygonIterator

friend class G4ReduciblePolygonIterator

friend

Definition at line 63 of file G4ReduciblePolygon.hh.

Member Data Documentation

◆ aMax

G4double G4ReduciblePolygon::aMax

protected

Definition at line 130 of file G4ReduciblePolygon.hh.

Referenced by Amax(), and CalculateMaxMin().

◆ aMin

G4double G4ReduciblePolygon::aMin

protected

Definition at line 130 of file G4ReduciblePolygon.hh.

Referenced by Amin(), and CalculateMaxMin().

◆ bMax

G4double G4ReduciblePolygon::bMax

protected

Definition at line 130 of file G4ReduciblePolygon.hh.

Referenced by Bmax(), and CalculateMaxMin().

◆ bMin

G4double G4ReduciblePolygon::bMin

protected

Definition at line 130 of file G4ReduciblePolygon.hh.

Referenced by Bmin(), and CalculateMaxMin().

◆ numVertices

G4int G4ReduciblePolygon::numVertices

protected

Definition at line 131 of file G4ReduciblePolygon.hh.

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

◆ vertexHead

ABVertex* G4ReduciblePolygon::vertexHead

protected

Definition at line 148 of file G4ReduciblePolygon.hh.

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

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

Classes

Public Member Functions

Protected Member Functions

Protected Attributes

Friends

Detailed Description

Constructor & Destructor Documentation

◆ G4ReduciblePolygon() [1/3]

◆ G4ReduciblePolygon() [2/3]

◆ ~G4ReduciblePolygon()

◆ G4ReduciblePolygon() [3/3]

Member Function Documentation

◆ Amax()

◆ Amin()

◆ Area()

◆ BisectedBy()

◆ Bmax()

◆ Bmin()

◆ CalculateMaxMin()

◆ CopyVertices()

◆ Create()

◆ CrossesItself()

◆ NumVertices()

◆ Print()

◆ RemoveDuplicateVertices()

◆ RemoveRedundantVertices()

◆ ReverseOrder()

◆ ScaleA()

◆ ScaleB()

Friends And Related Function Documentation

◆ ABVertex

◆ G4ReduciblePolygonIterator

Member Data Documentation

◆ aMax

◆ aMin

◆ bMax

◆ bMin

◆ numVertices

◆ vertexHead