G4ReduciblePolygon Class Reference

#include <G4ReduciblePolygon.hh>

Collaboration diagram for G4ReduciblePolygon:

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

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

Here is the call graph for this function:

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

Here is the call graph for this function:

G4ReduciblePolygon::~G4ReduciblePolygon ( )

virtual

Definition at line 149 of file G4ReduciblePolygon.cc.

{
  ABVertex *curr = vertexHead;
  while( curr )    // Loop checking, 13.08.2015, G.Cosmo
  {
    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.

{ return aMax; }

Here is the caller graph for this function:

G4double G4ReduciblePolygon::Amin ( ) const

inline

Definition at line 86 of file G4ReduciblePolygon.hh.

{ return aMin; }

Here is the caller graph for this function:

G4double G4ReduciblePolygon::Area

(

)

Definition at line 556 of file G4ReduciblePolygon.cc.

{
  G4double answer = 0;
  
  ABVertex *curr = vertexHead, *next;
  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 );
  
  return 0.5*answer;
}

Here is the caller graph for this function:

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

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

Here is the caller graph for this function:

G4double G4ReduciblePolygon::Bmax ( ) const

inline

Definition at line 89 of file G4ReduciblePolygon.hh.

{ return bMax; }

Here is the caller graph for this function:

G4double G4ReduciblePolygon::Bmin ( ) const

inline

Definition at line 88 of file G4ReduciblePolygon.hh.

{ return bMin; }

Here is the caller graph for this function:

void G4ReduciblePolygon::CalculateMaxMin ( )

protected

Definition at line 594 of file G4ReduciblePolygon.cc.

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

Here is the caller graph for this function:

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 )    // Loop checking, 13.08.2015, G.Cosmo
  {
    *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.

{
  if (n<3)
   G4Exception("G4ReduciblePolygon::Create()", "GeomSolids0002",
               FatalErrorInArgument, "Less than 3 vertices specified.");
  
  const G4double *anext = a, *bnext = b;
  ABVertex *prev = 0;
  do    // Loop checking, 13.08.2015, G.Cosmo
  {
    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();
}

Here is the call graph for this function:

Here is the caller graph for this function:

G4bool G4ReduciblePolygon::CrossesItself

(

G4double

tolerance

)

Definition at line 453 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)    // 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 )    // Loop checking, 13.08.2015, G.Cosmo
    {
      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;
}

Here is the caller graph for this function:

G4int G4ReduciblePolygon::NumVertices ( ) const

inline

Definition at line 84 of file G4ReduciblePolygon.hh.

{ return numVertices; }

Here is the caller graph for this function:

void G4ReduciblePolygon::Print

(

void

)

Definition at line 577 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 );
}

G4bool G4ReduciblePolygon::RemoveDuplicateVertices

(

G4double

tolerance

)

Definition at line 219 of file G4ReduciblePolygon.cc.

{
  ABVertex *curr = vertexHead, 
           *prev = 0, *next = 0;
  while( curr )    // Loop checking, 13.08.2015, G.Cosmo
  {
    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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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 )    // Loop checking, 13.08.2015, G.Cosmo
  {
    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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

Here is the caller graph for this function:

void G4ReduciblePolygon::ScaleA

(

G4double

scale

)

Definition at line 186 of file G4ReduciblePolygon.cc.

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

Here is the caller graph for this function:

void G4ReduciblePolygon::ScaleB

(

G4double

scale

)

Definition at line 202 of file G4ReduciblePolygon.cc.

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

void G4ReduciblePolygon::StartWithZMin

(

)

Definition at line 421 of file G4ReduciblePolygon.cc.

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

Here is the caller graph for this function:

Friends And Related Function Documentation

friend struct ABVertex

friend

Definition at line 140 of file G4ReduciblePolygon.hh.

friend class G4ReduciblePolygonIterator

friend

Definition at line 63 of file G4ReduciblePolygon.hh.

Member Data Documentation

G4double G4ReduciblePolygon::aMax

protected

Definition at line 131 of file G4ReduciblePolygon.hh.

G4double G4ReduciblePolygon::aMin

protected

Definition at line 131 of file G4ReduciblePolygon.hh.

G4double G4ReduciblePolygon::bMax

protected

Definition at line 131 of file G4ReduciblePolygon.hh.

G4double G4ReduciblePolygon::bMin

protected

Definition at line 131 of file G4ReduciblePolygon.hh.

G4int G4ReduciblePolygon::numVertices

protected

Definition at line 132 of file G4ReduciblePolygon.hh.

ABVertex* G4ReduciblePolygon::vertexHead

protected

Definition at line 149 of file G4ReduciblePolygon.hh.

---

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

• source/geant4.10.03.p03/source/geometry/solids/specific/include/G4ReduciblePolygon.hh
• source/geant4.10.03.p03/source/geometry/solids/specific/src/G4ReduciblePolygon.cc