G4ReduciblePolygon Class Reference

#include <G4ReduciblePolygon.hh>

Data Structures
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 ()
void	StartWithZMin ()
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::G4ReduciblePolygon	(	const G4double	a[],
		const G4double	b[],
		G4int	n
	)

Definition at line 49 of file G4ReduciblePolygon.cc.

References Create().

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

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

Definition at line 65 of file G4ReduciblePolygon.cc.

References test::a, test::b, Create(), and n.

  : 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 ( )

virtual

Definition at line 149 of file G4ReduciblePolygon.cc.

References curr(), G4ReduciblePolygon::ABVertex::next, and vertexHead.

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

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

G4double G4ReduciblePolygon::Amax ( ) const

inline

Definition at line 87 of file G4ReduciblePolygon.hh.

References aMax.

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

{ return aMax; }

G4double G4ReduciblePolygon::Amin ( ) const

inline

Definition at line 86 of file G4ReduciblePolygon.hh.

References aMin.

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

{ return aMin; }

G4double G4ReduciblePolygon::Area

(

)

Definition at line 556 of file G4ReduciblePolygon.cc.

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

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

{
  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;
}

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

Definition at line 511 of file G4ReduciblePolygon.cc.

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

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

{
  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;
}

G4double G4ReduciblePolygon::Bmax ( ) const

inline

Definition at line 89 of file G4ReduciblePolygon.hh.

References bMax.

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

{ return bMax; }

G4double G4ReduciblePolygon::Bmin ( ) const

inline

Definition at line 88 of file G4ReduciblePolygon.hh.

References bMin.

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

{ return bMin; }

void G4ReduciblePolygon::CalculateMaxMin ( )

protected

Definition at line 594 of file G4ReduciblePolygon.cc.

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

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

{
  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;
  }
}

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

Definition at line 168 of file G4ReduciblePolygon.cc.

References test::a, G4ReduciblePolygon::ABVertex::a, test::b, G4ReduciblePolygon::ABVertex::b, curr(), G4ReduciblePolygon::ABVertex::next, and vertexHead.

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

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

protected

Definition at line 103 of file G4ReduciblePolygon.cc.

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

Referenced by G4ReduciblePolygon().

{
  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();
}

G4bool G4ReduciblePolygon::CrossesItself

(

G4double

tolerance

)

Definition at line 453 of file G4ReduciblePolygon.cc.

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

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

{
  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;
}

G4int G4ReduciblePolygon::NumVertices ( ) const

inline

Definition at line 84 of file G4ReduciblePolygon.hh.

References numVertices.

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

{ return numVertices; }

void G4ReduciblePolygon::Print

(

void

)

Definition at line 577 of file G4ReduciblePolygon.cc.

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

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

G4bool G4ReduciblePolygon::RemoveDuplicateVertices

(

G4double

tolerance

)

Definition at line 219 of file G4ReduciblePolygon.cc.

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

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

{
  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;
}

G4bool G4ReduciblePolygon::RemoveRedundantVertices

(

G4double

tolerance

)

Definition at line 273 of file G4ReduciblePolygon.cc.

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

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

{
  //
  // 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;
}

void G4ReduciblePolygon::ReverseOrder

(

)

Definition at line 368 of file G4ReduciblePolygon.cc.

References curr(), G4ReduciblePolygon::ABVertex::next, and vertexHead.

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

{
  //
  // 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;
}

void G4ReduciblePolygon::ScaleA

(

G4double

scale

)

Definition at line 186 of file G4ReduciblePolygon.cc.

References G4ReduciblePolygon::ABVertex::a, curr(), G4ReduciblePolygon::ABVertex::next, and vertexHead.

Referenced by G4Polyhedra::G4Polyhedra().

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

void G4ReduciblePolygon::ScaleB

(

G4double

scale

)

Definition at line 202 of file G4ReduciblePolygon.cc.

References G4ReduciblePolygon::ABVertex::b, curr(), G4ReduciblePolygon::ABVertex::next, and vertexHead.

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

void G4ReduciblePolygon::StartWithZMin

(

)

Definition at line 421 of file G4ReduciblePolygon.cc.

References G4ReduciblePolygon::ABVertex::b, curr(), G4ReduciblePolygon::ABVertex::next, and vertexHead.

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

{ 
  ABVertex *curr = vertexHead;
  G4double bcurr = curr->b;
  ABVertex *prev = curr;
  while( curr )
  { 
    if(curr->b < bcurr)
    { 
      bcurr = curr->b;
      ABVertex *curr1 = curr;   
      while( curr1 )
      {
        if(curr1->next == 0) { curr1->next = vertexHead; break; }
        curr1 = curr1->next;
      }
      vertexHead = curr;         
      prev->next = 0;
    }
    prev = curr;
    curr = curr->next;
  }
}

Friends And Related Function Documentation

friend struct ABVertex

friend

Definition at line 140 of file G4ReduciblePolygon.hh.

Referenced by Create().

friend class G4ReduciblePolygonIterator

friend

Definition at line 63 of file G4ReduciblePolygon.hh.

Field Documentation

G4double G4ReduciblePolygon::aMax

protected

Definition at line 131 of file G4ReduciblePolygon.hh.

Referenced by Amax(), and CalculateMaxMin().

G4double G4ReduciblePolygon::aMin

protected

Definition at line 131 of file G4ReduciblePolygon.hh.

Referenced by Amin(), and CalculateMaxMin().

G4double G4ReduciblePolygon::bMax

protected

Definition at line 131 of file G4ReduciblePolygon.hh.

Referenced by Bmax(), and CalculateMaxMin().

G4double G4ReduciblePolygon::bMin

protected

Definition at line 131 of file G4ReduciblePolygon.hh.

Referenced by Bmin(), and CalculateMaxMin().

G4int G4ReduciblePolygon::numVertices

protected

Definition at line 132 of file G4ReduciblePolygon.hh.

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

ABVertex* G4ReduciblePolygon::vertexHead

protected

Definition at line 149 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:

• G4ReduciblePolygon.hh
• G4ReduciblePolygon.cc