G4SurfaceList Class Reference

#include <G4SurfaceList.hh>

Public Member Functions
	G4SurfaceList ()
	~G4SurfaceList ()
void	MoveToFirst (G4Surface *srf)
void	AddSurface (G4Surface *srf)
G4Surface *	GetSurface ()
const G4Surface *	GetSurface (G4int number)
const G4Surface *	GetLastSurface () const
void	RemoveSurface (G4Surface *srf)
void	RemovePointer ()
void	MoveToFirst ()
void	Step ()
void	EmptyList ()
void	G4SortList ()
void	QuickG4Sort (G4Surface **, G4int, G4int)
const G4Surface *	GetFirst () const
const G4Surface *	GetNext () const
G4int	GetSize () const

Detailed Description

Definition at line 43 of file G4SurfaceList.hh.

Constructor & Destructor Documentation

G4SurfaceList()

G4SurfaceList::G4SurfaceList

(

)

Definition at line 38 of file G4SurfaceList.cc.

{
  first = index = last = next = temp = (G4Surface*)0;
  number_of_elements=0; 
}

~G4SurfaceList()

G4SurfaceList::~G4SurfaceList

(

)

Definition at line 45 of file G4SurfaceList.cc.

{
  EmptyList();
}

Member Function Documentation

AddSurface()

void G4SurfaceList::AddSurface

(

G4Surface *

srf

)

Definition at line 63 of file G4SurfaceList.cc.

{
  if(first == (G4Surface*)0)
  {
    index = srf;
    first = srf;
    last = srf;
    first->SetNextNode(0);
  }
  else
  {
    srf->SetNextNode(last->GetNextNode());  
    last->SetNextNode(srf);
    last = last->GetNextNode();
  }
  
  number_of_elements++;  
  index=first;
}

EmptyList()

void G4SurfaceList::EmptyList

(

)

Definition at line 165 of file G4SurfaceList.cc.

{
  //Deletes all surfaces in List
  while (first != (G4Surface*)0)
  {
    temp  = first;
    first = first->GetNextNode();
    delete temp;
    number_of_elements--;
  }
  
  last = index = first;
}

Referenced by ~G4SurfaceList().

G4SortList()

void G4SurfaceList::G4SortList

(

)

Definition at line 193 of file G4SurfaceList.cc.

{
  if(number_of_elements == 1) return;
  
  // First create a vector of the surface distances
  // to the ray origin
  G4Surface** distances = new G4Surface*[number_of_elements];
  G4int x = 0;
  MoveToFirst();
 
  // Copy surface pointers to vector
  if(number_of_elements > 1)
  {
    while(x < number_of_elements)
    {
      distances[x] = index;
      index = index->GetNextNode();
      x++;
    }
    
    MoveToFirst();
 
    // Sort List of pointers using quick G4Sort
    QuickG4Sort( distances, 0, number_of_elements-1 );
    
    // Organize the linked List of surfaces according
    // to the quickG4Sorted List.
    x = 0;
    first = distances[x];
    last = first;
    x++;    
 
    while (x < number_of_elements)
    {
      last->SetNextNode(distances[x]);
      last = last->GetNextNode();
      x++;
    }
    
    last->SetNextNode(0);
    MoveToFirst();
  }
  
  delete[] distances;
}

GetFirst()

const G4Surface * G4SurfaceList::GetFirst ( ) const

inline

Definition at line 69 of file G4SurfaceList.hh.

{ return first; }

GetLastSurface()

const G4Surface * G4SurfaceList::GetLastSurface

(

)

const

Definition at line 100 of file G4SurfaceList.cc.

{
  return last;
}

GetNext()

const G4Surface * G4SurfaceList::GetNext ( ) const

inline

Definition at line 70 of file G4SurfaceList.hh.

{ return next;  }

GetSize()

G4int G4SurfaceList::GetSize ( ) const

inline

Definition at line 71 of file G4SurfaceList.hh.

{ return number_of_elements; }

Referenced by G4BSplineSurface::Intersect().

GetSurface() [1/2]

G4Surface * G4SurfaceList::GetSurface

(

)

Definition at line 84 of file G4SurfaceList.cc.

{
  return index;
}

Referenced by G4BSplineSurface::Intersect().

GetSurface() [2/2]

const G4Surface * G4SurfaceList::GetSurface

(

G4int

number

)

Definition at line 90 of file G4SurfaceList.cc.

{
  index = first;
  for(G4int a=0;a<number;a++)
    Step();
    
  return index;
}

MoveToFirst() [1/2]

void G4SurfaceList::MoveToFirst

(

)

Definition at line 180 of file G4SurfaceList.cc.

{
  index = first;
}

Referenced by G4SortList().

MoveToFirst() [2/2]

void G4SurfaceList::MoveToFirst

(

G4Surface *

srf

)

Definition at line 50 of file G4SurfaceList.cc.

{
  if(number_of_elements)
  {
    RemovePointer();
    srf->SetNextNode(first);  
    first = srf;
    index=first;
    number_of_elements++;  
  }
}

Referenced by G4BSplineSurface::Intersect().

QuickG4Sort()

void G4SurfaceList::QuickG4Sort	(	G4Surface **	Dist,
		G4int	left,
		G4int	right
	)

Definition at line 240 of file G4SurfaceList.cc.

{
  register G4int i=left;
  register G4int j=right;
  
  G4Surface* elem1;
  G4Surface* elem2 = Dist[(left+right)/2];
  
  do
  {
    while ( (Dist[i]->GetDistance() < elem2->GetDistance())  &&  (i < right) ) 
      i++;
    
    while ( (elem2->GetDistance() < Dist[j]->GetDistance())  &&  (j > left))
      j--;
 
    if(i<=j)
    {
      elem1   = Dist[i];
      Dist[i] = Dist[j];
      Dist[j] = elem1;
      i++;
      j--;
    }
  } while (i<=j); 
  
  if( left < j  ) 
    QuickG4Sort(Dist, left, j );
 
  if( i < right ) 
    QuickG4Sort(Dist, i, right);    
}

Referenced by G4SortList(), and QuickG4Sort().

RemovePointer()

void G4SurfaceList::RemovePointer

(

)

Definition at line 134 of file G4SurfaceList.cc.

{
  // Remove the current pointer from the List
  // Do not delete the object itself
  if(number_of_elements)
  {
    if(first != index)
    {
      temp = first;
      
      // Find previous
      while(temp->GetNextNode() != index) temp = temp->GetNextNode();
      
      // Hop over the one to be removed
      temp->SetNextNode(index->GetNextNode());
    
      // Correct the index pointer
      index = temp->GetNextNode();
    }
    else
    {
      // Hop over the first
      first = first->GetNextNode();
      index = first;
    }
  }
 
  number_of_elements--;
}

Referenced by MoveToFirst().

RemoveSurface()

void G4SurfaceList::RemoveSurface

(

G4Surface *

srf

)

Definition at line 106 of file G4SurfaceList.cc.

{
  if(srf!=(G4Surface*)0)
  {
    number_of_elements--;  
    temp = first;
    
    if(srf == first)
    {
      first=first->GetNextNode();
      index = first;
      if(number_of_elements == 0)last = first;
      delete srf;
      return;
    }
    else    
    {
      while(temp->GetNextNode() != srf) temp = temp->GetNextNode();
      index = srf->GetNextNode();
      temp->SetNextNode(index);
      if(srf == last) last = temp;
      index = first;
      delete srf;
    }
  }
}

Referenced by G4BezierSurface::ClipBothDirs().

Step()

void G4SurfaceList::Step

(

)

Definition at line 186 of file G4SurfaceList.cc.

{
  if(index!=(G4Surface*)0)
    index = index->GetNextNode();
}

Referenced by GetSurface(), and G4BSplineSurface::Intersect().

---

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

• G4SurfaceList.hh
• G4SurfaceList.cc