G4ReduciblePolygon Class Reference

#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 ()
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 = 0
ABVertex *	vertexHead = nullptr

Friends
class	G4ReduciblePolygonIterator
struct	ABVertex

Detailed Description

Definition at line 52 of file G4ReduciblePolygon.hh.

Constructor & Destructor Documentation

G4ReduciblePolygon() [1/3]

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

G4ReduciblePolygon() [2/3]

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

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

G4ReduciblePolygon() [3/3]

G4ReduciblePolygon::G4ReduciblePolygon

(

__void__ &

)

Definition at line 120 of file G4ReduciblePolygon.cc.

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

Member Function Documentation

Amax()

G4double G4ReduciblePolygon::Amax ( ) const

inline

Definition at line 78 of file G4ReduciblePolygon.hh.

{ return aMax; }

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

Amin()

G4double G4ReduciblePolygon::Amin ( ) const

inline

Definition at line 77 of file G4ReduciblePolygon.hh.

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

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

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

Bmax()

G4double G4ReduciblePolygon::Bmax ( ) const

inline

Definition at line 80 of file G4ReduciblePolygon.hh.

{ return 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.

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

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

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

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

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

NumVertices()

G4int G4ReduciblePolygon::NumVertices ( ) const

inline

Definition at line 75 of file G4ReduciblePolygon.hh.

{ return numVertices; }

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

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

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

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

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

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

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

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

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.

G4ReduciblePolygonIterator

friend class G4ReduciblePolygonIterator

friend

Definition at line 54 of file G4ReduciblePolygon.hh.

Member Data 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:

• G4ReduciblePolygon.hh
• G4ReduciblePolygon.cc