Provides a data structure accessing nodes, elements, and edges in a pane, in a manner similar to the halfedge data structure, assuming the elements form a 2-manifold. More...

#include <Simple_manifold_2.h>

Inheritance diagram for Simple_manifold_2:

[legend]

Collaboration diagram for Simple_manifold_2:

[legend]

Public Types
typedef Facet_ID	Edge_ID

Public Member Functions
	Simple_manifold_2 ()
	Default constructors. More...

	Simple_manifold_2 (const COM::Pane p, const Simple_manifold_2 parent=NULL, bool with_ghost=true)
	Constructors. More...

const COM::Pane *	pane () const
	Obtain a const pointer to the pane. More...

bool	is_real_node (int vID) const
	Is the given node a real node? More...

bool	is_ghost_node (int vID) const
	Is the given node a ghost node? More...

bool	is_real_element (int eid) const
	Is the element incident on the give edge a real element? More...

bool	is_ghost_element (int eid) const
	Is the element incident on the give edge a ghost element? More...

int	get_edge_index (const Edge_ID &eid, const int offset=0) const
	Get an index for internal edges. More...

int	upperbound_edge_index () const
	Get size of internal edges. More...

void	get_borders (std::vector< bool > &is_border, std::vector< bool > &is_isolated, std::vector< Edge_ID > b, int ng=NULL) const
	Obtain all the border nodes, isolated nodes, and border edges. More...

Size of nodes
int	size_of_nodes () const
	Number of nodes of the pane. More...

int	maxsize_of_nodes () const
	Maximum number of nodes allowed in the pane. More...

int	size_of_real_nodes () const
	Number of real nodes of the pane. More...

int	maxsize_of_real_nodes () const
	Maximum number of real nodes allowed in the pane. More...

int	size_of_ghost_nodes () const
	Number of ghost nodes of the pane. More...

int	maxsize_of_ghost_nodes () const
	Maximum number of ghost nodes allowed in the pane. More...

Size of faces
int	size_of_elements () const
	Number of elements of the pane. More...

int	maxsize_of_elements () const
	Maximum number of elements allowed in the pane. More...

int	size_of_real_elements () const
	Number of real elements of the pane. More...

int	maxsize_of_real_elements () const
	Maximum number of real elements allowed in the pane. More...

int	size_of_ghost_elements () const
	Number of ghost elements of the pane. More...

int	maxsize_of_ghost_elements () const
	Maximum number of ghost elements allowed in the pane. More...

int	size_of_faces () const
	Number of elements of the pane. More...

int	maxsize_of_faces () const
	Maximum number of elements allowed in the pane. More...

int	size_of_real_faces () const
	Number of real elements of the pane. More...

int	maxsize_of_real_faces () const
	Maximum number of real elements allowed in the pane. More...

int	size_of_ghost_faces () const
	Number of ghost elements of the pane. More...

int	maxsize_of_ghost_faces () const
	Maximum number of ghost elements allowed in the pane. More...

int	size_of_triangles () const
	Total number of triangles of the pane. More...

int	maxsize_of_triangles () const
	Maximum number of triangles allowed in the pane. More...

int	size_of_real_triangles () const
	Number of real triangles of the pane. More...

int	maxsize_of_real_triangles () const
	Maximum number of real triangles allowed in the pane. More...

int	size_of_ghost_triangles () const
	Number of ghost triangles of the pane. More...

int	maxsize_of_ghost_triangles () const
	Maximum number of ghost triangles allowed in the pane. More...

int	size_of_quadrilaterals () const
	Total number of quadrilaterals of the pane. More...

int	maxsize_of_quadrilaterals () const
	Maximum number of quadrilaterals allowed in the pane. More...

int	size_of_real_quadrilaterals () const
	Number of real quadrilaterals of the pane. More...

int	maxsize_of_real_quadrilaterals () const
	Maximum number of real quadrilaterals allowed in the pane. More...

int	size_of_ghost_quadrilaterals () const
	Number of ghost quadrilaterals of the pane. More...

int	maxsize_of_ghost_quadrilaterals () const
	Maximum number of ghost quadrilaterals allowed in the pane. More...

Size of edges
int	size_of_halfedges () const
	Number of halfedges of the pane. More...

int	size_of_real_halfedges () const
	Number of real halfedges of the pane. More...

int	size_of_ghost_halfedges () const
	Number of ghost halfedges of the pane. More...

int	size_of_edges () const
	Number of edges of the pane. More...

int	size_of_real_edges () const
	Number of real edges of the pane. More...

int	size_of_ghost_edges () const
	Number of ghost edges of the pane. More...

Size of border edges and nodes
int	size_of_border_edges () const
	Number of border edges of the whole pane. More...

int	size_of_real_border_edges () const
	Number of border edges of the real part of the pane. More...

int	size_of_ghost_border_edges () const
	Number of border edges of the ghost part of the pane. More...

int	size_of_isolated_nodes () const
	Number of isolated nodes. More...

Nodes and edges connectivity
int	get_origin (Edge_ID eID, Element_node_enumerator *ene_in=NULL) const
	Get the ID of the origin of a given edge. More...

int	get_destination (Edge_ID eID, Element_node_enumerator *ene_in=NULL) const
	Get the ID of the destination of a given edge. More...

Edge_ID	get_incident_edge (int vID) const
	Get the ID of an incident edge within the pane of a given node that originated from the node. More...

Edge_ID	get_incident_real_edge (int vID) const
	Get the ID of an incident real edge within the pane of a given node. More...

Edge_ID	get_incident_ghost_edge (int vID) const
	Get the ID of an incident real edge within the pane of a given node The incident edge may encode an isolated node. More...

Border nodes and edges
bool	is_border_edge (const Edge_ID &eID) const
	Is a given edge on the boundary of the whole pane? More...

bool	is_pure_real_border_edge (const Edge_ID &eID) const
	Determine whether a given edge is a border edge of real part of the whole pane (on physical border). More...

bool	is_real_border_edge (const Edge_ID &eID) const
	Determine whether a given edge is a border edge of real part of the pane (either on physical border or between real and ghost elements) More...

bool	is_ghost_border_edge (const Edge_ID &eID) const
	Determine whether a given edge is a border edge of ghost part of the pane (either on physical border or between real and ghost elements) More...

bool	is_isolated_node (int vID) const
	Is the node isolated (i.e. not incident on any element)? More...

bool	is_real_border_node (int vID) const
	Is the node on the pane boundary of real part (not isolated)? More...

bool	is_ghost_border_node (int vID) const
	Is the node on pane boundary (not isolated)? It assumes vID is incident on the ghost (no checking is performed). More...

bool	is_border_node (int vID) const
	Is the node on pane boundary (not isolated)? More...

int	get_border_edgeID (Edge_ID eID) const
	Get the border edge index. Return -1 if not a border edge. More...

Edge_ID	get_a_real_border_edge () const
	Obtain a border edge on real part of the pane. More...

Edge_ID	get_a_ghost_border_edge () const
	Obtain a border edge on ghost part of the pane. More...

Edge_ID	get_a_border_edge () const
	Obtain the ID of a border edge of the whole pane. More...

int	get_a_real_border_node () const
	Obtain the ID of a border node of the real part of the pane. More...

int	get_a_ghost_border_node () const
	Obtain the ID of a border node of the ghost part of the pane. More...

int	get_a_border_node () const
	Obtain the ID of a border node. More...

Protected Member Functions
void	init (const COM::Pane p, const Simple_manifold_2 parent=NULL, bool with_ghost=true)
	Initialize the database for the pane, including ghost information, opposite halfedges, incident halfedges, and border halfedges. More...

void	determine_ghosts ()
	Determine the ghost nodes and elements. More...

void	determine_opposite_halfedges ()
	Determine the opposite halfedges of each halfedge, and identify border halfedge. More...

void	determine_incident_halfedges ()
	Determine an incident halfedge for each node. More...

Protected Attributes
const COM::Pane *	_pane

bool	_is_str

bool	_with_ghost

std::vector< const COM::Connectivity * >	_elem_conns

int	_nspe

int	_maxsize_real_nodes

int	_maxsize_real_elmts

int	_size_real_borders

int	_size_ghost_borders

int	_size_rg_borders

std::vector< bool >	_isghostnode

std::vector< bool >	_isghostelmt

std::vector< Edge_ID >	_oeIDs_real_or_str

std::vector< Edge_ID >	_oeIDs_ghost

std::vector< Edge_ID >	_ieIDs_real_or_str

std::vector< Edge_ID >	_ieIDs_ghost

std::vector< Edge_ID >	_beIDs

std::vector< int >	_isovIDs

Opposite Edges
Edge_ID	get_opposite_real_edge (const Edge_ID &eID) const
	Get the ID of the opposite real edge of a given real or border edge. More...

Edge_ID	get_opposite_ghost_edge (const Edge_ID &eID) const
	Get the ID of the opposite ghost edge of a given real or border edge. More...

Edge_ID	get_opposite_edge (const Edge_ID &eID) const
	Get the ID of the opposite edge of a given interior or border edge. More...

Edge_ID	get_opposite_edge_interior (const Edge_ID &eID) const
	Get the opposite edge of an interior edge of the whole pane. More...

Edge_ID	get_opposite_real_edge_interior (const Edge_ID &eID) const
	Get the opposite edge of an interior edge of the real part. More...

Edge_ID	get_opposite_ghost_edge_interior (const Edge_ID &eID) const
	Get the opposite edge of an interior edge of the ghost part. More...

Edge_ID	get_opposite_edge_border (const Edge_ID &eID) const
	Get the opposite edge of a border edge for the whole pane. More...

Edge_ID	get_opposite_real_edge_border (const Edge_ID &eID) const
	Get the opposite edge of a border edge for the real pane. More...

Edge_ID	get_opposite_ghost_edge_border (const Edge_ID &eID) const
	Get the opposite edge of a border edge for the ghost pane. More...

Previous and next Edges
Edge_ID	get_prev_edge (const Edge_ID &eID) const
	Get the ID of the previous edge of the element or along the boundary. More...

Edge_ID	get_prev_real_edge (const Edge_ID &eID) const
	Get the ID of the previous real edge of the element or along the boundary. More...

Edge_ID	get_prev_ghost_edge (const Edge_ID &eID) const
	Get the ID of the previous ghost edge of the element or along the boundary. More...

Edge_ID	get_next_edge (const Edge_ID &eID) const
	Get the ID of the next edge of the element or along the boundary. More...

Edge_ID	get_next_real_edge (const Edge_ID &eID) const
	Get the ID of the next real edge of the element or along the boundary. More...

Edge_ID	get_next_ghost_edge (const Edge_ID &eID) const
	Get the ID of the next ghost edge of the element or along the boundary. More...

Edge_ID	get_prev_edge_interior (const Edge_ID &eID) const

Edge_ID	get_prev_real_edge_interior (const Edge_ID &eID) const

Edge_ID	get_prev_ghost_edge_interior (const Edge_ID &eID) const

Edge_ID	get_next_edge_interior (const Edge_ID &eID) const

Edge_ID	get_next_real_edge_interior (const Edge_ID &eID) const

Edge_ID	get_next_ghost_edge_interior (const Edge_ID &eID) const

Detailed Description

Provides a data structure accessing nodes, elements, and edges in a pane, in a manner similar to the halfedge data structure, assuming the elements form a 2-manifold.

It provides interfaces for accessing the real part, the ghost part, or the whole pane.

Definition at line 80 of file Simple_manifold_2.h.

Member Typedef Documentation

typedef Facet_ID Edge_ID

Definition at line 82 of file Simple_manifold_2.h.

Constructor & Destructor Documentation

Simple_manifold_2 ( )

inline

Default constructors.

Definition at line 85 of file Simple_manifold_2.h.

     : _pane(NULL), _is_str(0), _with_ghost(0), _nspe(0),
       _maxsize_real_nodes(-1), _maxsize_real_elmts(-1), 
       _size_real_borders(0), _size_ghost_borders(0), _size_rg_borders(0) {}

Simple_manifold_2	(	const COM::Pane *	p,
		const Simple_manifold_2 *	parent = `NULL`,
		bool	with_ghost = `true`
	)

inlineexplicit

Constructors.

Definition at line 91 of file Simple_manifold_2.h.

References init().

94 { init(p, parent, with_ghost); }

Simple_manifold_2::init

void init(const COM::Pane *p, const Simple_manifold_2 *parent=NULL, bool with_ghost=true)

Initialize the database for the pane, including ghost information, opposite halfedges, incident halfedges, and border halfedges.

Definition: Simple_manifold_2.C:31

Here is the call graph for this function:

Member Function Documentation

void determine_ghosts ( )

protected

Determine the ghost nodes and elements.

Definition at line 81 of file Simple_manifold_2.C.

References _is_str, _isghostelmt, _isghostnode, _pane, _with_ghost, and COM_assertion_msg.

Referenced by init().

                    {
   // _isghostnode and _isghostelmt not used for unstructured meshes 
   // and meshes without ghost
   _isghostnode.clear();
   _isghostelmt.clear();
 
   if ( !_is_str || !_with_ghost) return;
 
   // Fill in _isghostnode and _isghostelmt for structured mesh with ghosts
   _isghostnode.resize( _pane->size_of_nodes(), false);
   _isghostelmt.resize( _pane->size_of_elements(), false);
 
   COM_assertion_msg( false, 
                      "Not fully implemented yet for structured mesh");
 }

Here is the caller graph for this function:

void determine_incident_halfedges ( )

protected

Determine an incident halfedge for each node.

If the node is a border node, then determine its incident border halfedge. If the pane is unstructured and contains isolated nodes, determine an ordering of the isolated nodes.

Definition at line 250 of file Simple_manifold_2.C.

References _beIDs, _ieIDs_ghost, _ieIDs_real_or_str, _is_str, _isovIDs, _maxsize_real_elmts, _maxsize_real_nodes, _pane, _with_ghost, COM_assertion, COM_assertion_msg, get_opposite_ghost_edge_interior(), get_opposite_real_edge_interior(), get_origin(), i, Element_node_enumerator::id(), is_border_edge(), is_real_element(), is_real_node(), j, min(), Element_node_enumerator::next(), ni, Element_node_enumerator::size_of_edges(), and Element_node_enumerator::size_of_nodes().

Referenced by init().

                                {
   COM_assertion_msg( _is_str || 
                      int(_pane->size_of_real_nodes())==_maxsize_real_nodes &&
                      int(_pane->size_of_real_elements())==_maxsize_real_elmts, 
                      "Support for maxsize not yet fully implemented");
 
   int nnodes, nelems;
   if ( _is_str) { // For structured meshes, real and ghost are stored together
     nnodes = _pane->size_of_nodes();
     nelems = _pane->size_of_elements();
   }
   else {
     nnodes = _pane->size_of_real_nodes();
     nelems = _pane->size_of_real_elements();
   }
 
   _ieIDs_real_or_str.clear(); _ieIDs_real_or_str.resize( nnodes, Edge_ID());
 
   Element_node_enumerator ene( _pane, 1); 
   for ( int j=0; j<nelems; ++j, ene.next()) {
     int ne=ene.size_of_edges();
 
     for ( int i=0; i<ne; ++i) {
       int vID=ene[i];
 
       // If the incident elements has not been assigned, or the
       // incident edge is a border edge, then assign the incident elements.
       Edge_ID prev( ene.id(),i?i-1:ne-1);
       Edge_ID eoppID = is_real_element( ene.id()) ?
         get_opposite_real_edge_interior( prev) :
         get_opposite_ghost_edge_interior( prev);
 
       Edge_ID &iid = _ieIDs_real_or_str[ vID-1];
       if ( eoppID.is_border() && !is_border_edge( iid)) {
         iid = eoppID;
         COM_assertion( get_origin( iid) == vID);
       }
       else if ( iid==Edge_ID()) {
         iid = Edge_ID( ene.id(), i);
         COM_assertion( get_origin( iid, &ene) == vID);
       }
     }
 
     // Special treatment for edge centers of quadratic elements
     int ne2 = std::min(ne+ne,ene.size_of_nodes());
     for ( int i=ne, ni=ne2; i<ni; ++i) {
       int vID=ene[i];
 
       // Make sure every edge centers points to one of its halfedge, and 
       // always points to the border halfedge if on the boundary.
       Edge_ID eID( ene.id(), i-ne);
       Edge_ID eoppID = is_real_element( ene.id()) ?
         get_opposite_real_edge_interior( eID) :
         get_opposite_ghost_edge_interior( eID);
 
       Edge_ID &iid = _ieIDs_real_or_str[ vID-1];
       if ( eoppID.is_border() && !is_border_edge( iid))
         iid =eoppID;
       else if ( iid==Edge_ID())
         iid = eID;
     }
 
     // Finally, handle face center. 
     if ( ne2<ene.size_of_nodes())
       _ieIDs_real_or_str[ene[ne2]-1] = Edge_ID(ene.id(),0);
   }
 
   if (!_is_str) {
     // Identify isolated nodes that are not incident on any element
     // and create a numbering for the isolated nodes.
     _isovIDs.clear();
     // Loop through all the nodes
     for ( int i=1; i<=nnodes; ++i) {
       Edge_ID &iid = _ieIDs_real_or_str[ i-1];
       if ( iid == Edge_ID()) {
         _isovIDs.push_back( i);
         iid = Edge_ID( _beIDs.size()+_isovIDs.size(), -1);
       }
     }
   }
 
   // We are done for structured mesh and unstructured without ghost
   nnodes = _with_ghost ? _pane->size_of_ghost_nodes() : 0;
   _ieIDs_ghost.clear(); _ieIDs_ghost.resize( nnodes, Edge_ID());
   if ( _is_str || nnodes==0) return;
 
   // Handle ghost nodes and elements
   nelems = _pane->size_of_ghost_elements();
   if ( nelems>0) ene = Element_node_enumerator( _pane, _maxsize_real_elmts+1);
 
   for ( int j=0; j<nelems; ++j, ene.next()) {
     int ne=ene.size_of_edges();
 
     for ( int i=0; i<ne; ++i) {
       int vID=ene[i];
       if ( is_real_node( vID)) continue; // skip real nodes.
 
       // If the incident elements has not been assigned, or the
       // incident edge is a border edge, then assign the incident elements.
       Edge_ID prev( ene.id(),i?i-1:ne-1);
       Edge_ID eoppID = get_opposite_ghost_edge_interior( prev);
 
       Edge_ID &iid = _ieIDs_ghost[ vID-_maxsize_real_nodes-1];
       if ( eoppID.is_border() && !is_border_edge( iid)) {
         iid = eoppID;
         COM_assertion( get_origin( iid) == vID);
       }
       else if ( iid==Edge_ID()) {
         iid = Edge_ID( ene.id(), i);
         COM_assertion( get_origin( iid, &ene) == vID);
       }
     }
 
     // Special treatment for edge centers of quadratic elements
     int ne2 = std::min(ne+ne,ene.size_of_nodes());
     for ( int i=ne, ni=ne2; i<ni; ++i) {
       int vID=ene[i];
       if ( is_real_node( vID)) continue; // skip real nodes.
 
       // Make sure every edge centers points to one of its halfedge, and 
       // always points to the border halfedge if on the boundary.
       Edge_ID eID( ene.id(), i-ne);
       Edge_ID eoppID = get_opposite_ghost_edge_interior(eID);
 
       Edge_ID &iid = _ieIDs_ghost[ vID-_maxsize_real_nodes-1];
       if ( eoppID.is_border() && !is_border_edge( iid)) {
         iid =eoppID;
         COM_assertion( get_origin( iid) == vID);
       }
       else if ( iid==Edge_ID()) {
         iid = eID;
         COM_assertion( get_origin( iid, &ene) == vID);
       }
     }
 
     // Finally, handle face center.
     if ( ne2<ene.size_of_nodes())
       _ieIDs_ghost[ene[ne2]-_maxsize_real_nodes-1] = Edge_ID(ene.id(),0);
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void determine_opposite_halfedges ( )

protected

Determine the opposite halfedges of each halfedge, and identify border halfedge.

Definition at line 98 of file Simple_manifold_2.C.

References _beIDs, _is_str, _maxsize_real_elmts, _nspe, _oeIDs_ghost, _oeIDs_real_or_str, _pane, _size_ghost_borders, _size_real_borders, _size_rg_borders, _with_ghost, Facet_ID::BndID, COM_assertion, Facet_ID::eid(), get_edge_index(), i, Element_node_enumerator::id(), Pane_dual_connectivity::incident_elements(), is_ghost_element(), is_real_element(), j, k, Element_node_enumerator::next(), nk, and Element_node_enumerator::size_of_edges().

Referenced by init().

                                {
 
   // Compute the dual connectivity.
   Pane_dual_connectivity pdc( _pane, _with_ghost);
   
   int nr = _nspe*_pane->size_of_real_elements();
   _oeIDs_real_or_str.clear(); _oeIDs_real_or_str.resize( nr, Edge_ID());
 
   int ng = _with_ghost ? _nspe*_pane->size_of_ghost_elements():0;
   _oeIDs_ghost.clear(); _oeIDs_ghost.resize( ng, Edge_ID());
 
   // Buffer array for holding border edges between real and ghost
   std::vector<Edge_ID>   beIDs_rg;
 
   // Determine the neighbor elements from the dual connectivity.
   Element_node_enumerator ene( _pane, 1); 
   std::vector<int> ies1, ies2;
   std::vector<int> ies_common; ies_common.reserve(2);
 
   // Process real elements of unstructured meshes or structured meshes
   int nn = _is_str && _with_ghost
     ? _pane->size_of_elements():_pane->size_of_real_elements(); 
   for ( int j=0; j<nn; ++j, ene.next()) {
     const int ne = ene.size_of_edges(); 
     COM_assertion( _nspe>=ne);
 
     int ij = j*_nspe;
     for ( int i=0; i<ne; ++i, ++ij) {
       // Determine the elements that incident on both nodes of the edge
       pdc.incident_elements( ene[i], ies1);
       pdc.incident_elements( ene[(i==ne-1)?0:i+1], ies2);
       
       ies_common.clear();
       std::back_insert_iterator< std::vector<int> > ii(ies_common);;
       std::set_intersection( ies1.begin(), ies1.end(),
                              ies2.begin(), ies2.end(), ii);
       COM_assertion( ies_common.size()<=2);
       
       int eid=0;
       for ( std::vector<int>::iterator it_ies = ies_common.begin();
             it_ies != ies_common.end(); ++it_ies)
         if ( *it_ies != ene.id()) { eid = *it_ies; break; }
       
       // Determing the local side ID
       if ( eid) {
         int node_id = ene[i];
         Element_node_enumerator ene_opp( _pane, eid);
         const int nk=ene_opp.size_of_edges();
         for ( int k=0; k<nk; ++k) if ( ene_opp[k] == node_id) {
           Edge_ID opp = Edge_ID( eid, k?k-1:nk-1);
           
           bool isreal_edge = !_with_ghost || !_is_str || is_real_element( ene.id());
           bool isghost_opp = _with_ghost && is_ghost_element( eid);
 
           if ( isreal_edge || isghost_opp)
             // ghost elements of structured mesh 
             _oeIDs_real_or_str[ij] = opp;
 
           // Insert border edges incident on ghost elements into _beIDs_rg
           if ( isghost_opp && isreal_edge) {
             beIDs_rg.push_back( Edge_ID( ene.id(), i));
 
             Edge_ID bid = Edge_ID( beIDs_rg.size(), Edge_ID::BndID); 
             if (_is_str)
               _oeIDs_real_or_str[ get_edge_index( opp)] = bid;
             else 
               _oeIDs_ghost[ get_edge_index( opp, _maxsize_real_elmts)] = bid;
           }
 
           break;
         }
         COM_assertion( _oeIDs_real_or_str[ij] != Edge_ID());
       } // eid
       else {
         // Insert border edges of the real part into _beIDs
         _beIDs.push_back( Edge_ID(ene.id(), i));
         _oeIDs_real_or_str[ij] = Edge_ID( _beIDs.size(), Edge_ID::BndID);
       }
     }
   }
   
   // Save the number of real borders edges.
   _size_real_borders = _beIDs.size();
   _size_rg_borders = beIDs_rg.size();
 
   // Update the rg_border IDs
   for ( int i=0; i<_size_rg_borders; ++i) {
     Edge_ID gid = _oeIDs_real_or_str[get_edge_index(beIDs_rg[i])];
 
     Edge_ID *bid;
     if ( _is_str)
       bid = &_oeIDs_real_or_str[ get_edge_index( gid)];
     else
       bid = &_oeIDs_ghost[ get_edge_index( gid, _maxsize_real_elmts)];
 
     COM_assertion( bid->eid() == i+1);
     *bid = Edge_ID( bid->eid()+_size_real_borders, Edge_ID::BndID);
   }
 
   // Merge _beIDs and beIDs_rg together
   _beIDs.insert( _beIDs.end(), beIDs_rg.begin(), beIDs_rg.end());
   beIDs_rg.clear();
 
   // Process ghost elements
   nn = _is_str || !_with_ghost ? 0 : _pane->size_of_ghost_elements();
   if ( nn) ene = Element_node_enumerator( _pane, _maxsize_real_elmts+1); 
   for ( int j=0; j<nn; ++j, ene.next()) {
     const int ne = ene.size_of_edges(); 
     COM_assertion( _nspe>=ne);
 
     int ij = j*_nspe;
     for ( int i=0; i<ne; ++i, ++ij) {
       // Determine the elements that incident on both nodes of the edge
       pdc.incident_elements( ene[i], ies1);
       pdc.incident_elements( ene[(i==ne-1)?0:i+1], ies2);
       
       ies_common.clear();
       std::back_insert_iterator< std::vector<int> > ii(ies_common);;
       std::set_intersection( ies1.begin(), ies1.end(),
                              ies2.begin(), ies2.end(), ii);
       COM_assertion( ies_common.size()<=2);
       
       int eid=0;
       for ( std::vector<int>::iterator it_ies = ies_common.begin();
             it_ies != ies_common.end(); ++it_ies)
         if ( *it_ies != ene.id()) { eid = *it_ies; break; }
       
       // Determing the local side ID
       if ( eid) {
         if ( is_real_element( eid)) continue;
 
         int node_id = ene[i];
         Element_node_enumerator ene_opp( _pane, eid);
         const int nk=ene_opp.size_of_edges();
         for ( int k=0; k<nk; ++k) if ( ene_opp[k] == node_id) {
           _oeIDs_ghost[ij] = Edge_ID( eid, k?k-1:nk-1);
           break;
         }
         COM_assertion( _oeIDs_ghost[ij] != Edge_ID());
       }
       else {
         // Insert border edges of the ghost part of the pane into _beIDs
         _beIDs.push_back( Edge_ID(ene.id(), i));
         _oeIDs_ghost[ij] = Edge_ID( _beIDs.size(), Edge_ID::BndID);
       }
     }
   }
 
   _size_ghost_borders = _beIDs.size() - _size_real_borders - _size_rg_borders;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Edge_ID get_a_border_edge ( ) const

inline

Obtain the ID of a border edge of the whole pane.

Definition at line 569 of file Simple_manifold_2.h.

References _size_ghost_borders, _size_real_borders, _size_rg_borders, and Facet_ID::BndID.

                                     { 
     if ( _size_real_borders>0) 
       return Edge_ID( 1, Edge_ID::BndID);
     else if ( _size_ghost_borders>0)
       return Edge_ID( _size_rg_borders, Edge_ID::BndID);
     else
       return Edge_ID();
   }

int get_a_border_node ( ) const

inline

Obtain the ID of a border node.

Definition at line 596 of file Simple_manifold_2.h.

References _beIDs, _size_ghost_borders, _size_real_borders, _size_rg_borders, and get_origin().

                                 {
     if ( _size_real_borders>0) 
       return get_origin(_beIDs[0]);
     else if ( _size_ghost_borders>0)
       return get_origin( _beIDs[_size_rg_borders]);
     else
       return -1;
   }

Here is the call graph for this function:

Edge_ID get_a_ghost_border_edge ( ) const

inline

Obtain a border edge on ghost part of the pane.

Maybe between real and ghost.

Definition at line 561 of file Simple_manifold_2.h.

References _size_ghost_borders, _size_real_borders, _size_rg_borders, and Facet_ID::BndID.

                                            {
     if ( _size_ghost_borders>0 || _size_rg_borders>0) 
       return Edge_ID(_size_real_borders+_size_rg_borders+1, Edge_ID::BndID);
     else
       return Edge_ID();
   }

int get_a_ghost_border_node ( ) const

inline

Obtain the ID of a border node of the ghost part of the pane.

The node, however, may be a real node.

Definition at line 588 of file Simple_manifold_2.h.

References _beIDs, _size_ghost_borders, _size_real_borders, _size_rg_borders, and get_origin().

                                       {
     if ( _size_ghost_borders>0 || _size_rg_borders>0) 
       return get_origin( _beIDs[_size_real_borders]);
     else
       return -1;
   }

Here is the call graph for this function:

Edge_ID get_a_real_border_edge ( ) const

inline

Obtain a border edge on real part of the pane.

Definition at line 552 of file Simple_manifold_2.h.

References _size_real_borders, _size_rg_borders, and Facet_ID::BndID.

                                          {
     if ( _size_real_borders>0 || _size_rg_borders>0) 
       return Edge_ID( 1, Edge_ID::BndID);
     else 
       return Edge_ID();
   }

int get_a_real_border_node ( ) const

inline

Obtain the ID of a border node of the real part of the pane.

Definition at line 579 of file Simple_manifold_2.h.

References _beIDs, _size_real_borders, _size_rg_borders, and get_origin().

                                      { 
     if ( _size_real_borders>0 || _size_rg_borders>0) 
       return get_origin(_beIDs[0]);
     else 
       return -1;
   }

Here is the call graph for this function:

int get_border_edgeID ( Edge_ID eID ) const

inline

Get the border edge index. Return -1 if not a border edge.

Definition at line 546 of file Simple_manifold_2.h.

References Facet_ID::eid(), and Facet_ID::is_border().

Referenced by Window_manifold_2::determine_counterparts(), and Pane_manifold_2::is_physical_border_edge().

                                             {
     if ( !eID.is_border()) { assert(false); return -1; }
     else return eID.eid();
   }

Here is the call graph for this function:

Here is the caller graph for this function:

void get_borders	(	std::vector< bool > &	is_border,
		std::vector< bool > &	is_isolated,
		std::vector< Edge_ID > *	b,
		int *	ng = `NULL`
	)		const

Obtain all the border nodes, isolated nodes, and border edges.

If ng is not NULL, then obtain the borders of the whole pane (including the ghost part), and load the number of ghost nodes into ng.

Definition at line 392 of file Simple_manifold_2.C.

References _beIDs, _is_str, _maxsize_real_nodes, _size_ghost_borders, _size_real_borders, _size_rg_borders, _with_ghost, i, is_border_node(), is_isolated_node(), is_real_border_node(), offset(), size_of_ghost_nodes(), and size_of_real_nodes().

                             {
 
   int nr = size_of_real_nodes();
   int nnodes;
   
   if ( ng != NULL) {
     *ng = _with_ghost ? size_of_ghost_nodes() : 0;
     nnodes = nr + *ng;
   }
   else 
     nnodes = nr;
 
   // First, get the isolated nodes
   is_isolated.resize( nnodes, false);
   if ( !_is_str) {
     for ( int i=0; i<nr; ++i)
       is_isolated[ i] = is_isolated_node( i+1);
   }
 
   // Second, obtain the border nodes
   is_border.resize( nnodes, false);
   if ( ng && *ng) {
     for ( int i=0; i<nr; ++i)
       is_border[ i] = is_border_node( i+1);
 
     // Loop through all the nodes
     const int offset=_maxsize_real_nodes-nr+1, nlast = nr+*ng;
     for ( int i=nr; i<nlast; ++i)
       is_border[ i] = is_border_node( offset+i);
   }
   else {
     for ( int i=0; i<nr; ++i)
       is_border[ i] = is_real_border_node( i+1);
   }
 
   // Finally, fill in the border edges into b if exist.
   if ( b) {
     b->clear();
 
     if ( ng) {
       b->reserve( _size_real_borders+_size_ghost_borders);
       b->insert( b->end(), &_beIDs[0], &_beIDs[_size_real_borders]);
 
       int nstart=_size_real_borders+_size_rg_borders;
       b->insert( b->end(), &_beIDs[nstart],
                  &_beIDs[nstart+_size_ghost_borders]);
     }
     else {
       b->insert( b->end(), &_beIDs[0], 
                  &_beIDs[_size_real_borders+_size_rg_borders]);
     }
   }
 }

Here is the call graph for this function:

int get_destination	(	Edge_ID	eID,
		Element_node_enumerator *	ene_in = `NULL`
	)		const

inline

Get the ID of the destination of a given edge.

Definition at line 375 of file Simple_manifold_2.h.

References _pane, Facet_ID::eid(), get_opposite_ghost_edge_border(), get_opposite_real_edge_border(), Facet_ID::is_border(), is_real_border_edge(), and Facet_ID::lid().

Referenced by Halfedge::destination().

                                                                                 {
     if ( eID.is_border()) {
       Edge_ID opp;
       if (is_real_border_edge( eID)) opp = get_opposite_real_edge_border( eID);
       else opp = get_opposite_ghost_edge_border( eID);
       
       Element_node_enumerator ene( _pane, opp.eid());
       return ene[opp.lid()];
     }
     else {
       if ( ene_in)
         return (*ene_in)[eID.lid()+1==ene_in->size_of_edges()?0:eID.lid()+1];
       else {
         Element_node_enumerator ene( _pane, eID.eid());
         return ene[eID.lid()+1==ene.size_of_edges()?0:eID.lid()+1];
       }
     }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

int get_edge_index	(	const Edge_ID &	eid,
		const int	offset = `0`
	)		const

inline

Get an index for internal edges.

Definition at line 639 of file Simple_manifold_2.h.

References _nspe, Facet_ID::eid(), Facet_ID::lid(), and offset().

Referenced by determine_opposite_halfedges(), get_incident_edge(), get_next_edge_interior(), get_next_ghost_edge_interior(), get_next_real_edge_interior(), get_opposite_ghost_edge_border(), get_opposite_ghost_edge_interior(), get_opposite_real_edge_interior(), get_prev_edge_interior(), get_prev_ghost_edge_interior(), and get_prev_real_edge_interior().

640 { return (eid.eid()-offset-1)*_nspe+eid.lid(); }

offset

real *8 function offset(vNorm, x2, y2, z2)

Definition: PlaneNorm.f90:211

Simple_manifold_2::_nspe

int _nspe

Definition: Simple_manifold_2.h:867

Here is the call graph for this function:

Here is the caller graph for this function:

Edge_ID get_incident_edge ( int vID ) const

inline

Get the ID of an incident edge within the pane of a given node that originated from the node.

If the vertex is on the pane boundary, it will return a border edge. For isolated nodes, it returns an ID similar to that for a border edge, except that the element ID given will be the index of the isolated node (starting from 1) plus the total number of border edges.

Definition at line 400 of file Simple_manifold_2.h.

References _beIDs, _ieIDs_ghost, _ieIDs_real_or_str, _is_str, _maxsize_real_nodes, _oeIDs_real_or_str, _size_real_borders, _size_rg_borders, COM_assertion, Facet_ID::eid(), get_edge_index(), get_origin(), Facet_ID::is_border(), and is_ghost_node().

Referenced by Node::halfedge().

                                             { 
     Edge_ID eID;
     if ( _is_str || !is_ghost_node( vID))
       eID = _ieIDs_real_or_str[ vID-1]; 
     else
       eID = _ieIDs_ghost[ vID-_maxsize_real_nodes-1];
 
     // If the edge is between real and ghost, then return the real edge.
     if ( eID.is_border() && eID.eid()>_size_real_borders && 
          eID.eid()<=_size_real_borders+_size_rg_borders) {
       eID = _oeIDs_real_or_str[ get_edge_index(_beIDs[eID.eid()-1])];
       COM_assertion( get_origin( eID)==vID);
     }
     return eID;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

Edge_ID get_incident_ghost_edge ( int vID ) const

inline

Get the ID of an incident real edge within the pane of a given node The incident edge may encode an isolated node.

Definition at line 439 of file Simple_manifold_2.h.

References _ieIDs_ghost, _ieIDs_real_or_str, _is_str, _maxsize_real_nodes, _size_real_borders, COM_assertion_msg, Facet_ID::eid(), get_next_real_edge_interior(), get_opposite_real_edge_border(), get_opposite_real_edge_interior(), Facet_ID::is_border(), is_ghost_border_edge(), and is_ghost_node().

                                                   {
     bool isghost = is_ghost_node( vID);
     Edge_ID eID;
     if ( _is_str || !isghost)
       eID = _ieIDs_real_or_str[ vID-1]; 
     else
       eID = _ieIDs_ghost[ vID-_maxsize_real_nodes-1];
     if ( isghost) return eID;
 
     if ( eID.is_border() && eID.eid()<=_size_real_borders) {
       // If vID is between real and ghost, and on the real boundary,
       // get the border edge between real and ghost.
       eID = get_opposite_real_edge_border( eID);
       Edge_ID eID0 = eID;
       while ( (eID = get_opposite_real_edge_interior
                ( get_next_real_edge_interior(eID))) != eID0 &&
               !is_ghost_border_edge( eID));
       COM_assertion_msg( eID.is_border(),
                          "No ghost edge incident on given vertex"); 
     }
 
     return eID;
   }

Here is the call graph for this function:

Edge_ID get_incident_real_edge ( int vID ) const

inline

Get the ID of an incident real edge within the pane of a given node.

The incident edge may encode an isolated node.

Definition at line 418 of file Simple_manifold_2.h.

References _beIDs, _ieIDs_real_or_str, _size_real_borders, _size_rg_borders, COM_assertion, COM_assertion_msg, Facet_ID::eid(), get_next_ghost_edge_interior(), get_opposite_ghost_edge_border(), get_opposite_ghost_edge_interior(), get_origin(), Facet_ID::is_border(), is_real_border_edge(), and is_real_node().

Referenced by Pane_manifold_2::get_bnode_index(), and Node::halfedge().

                                                  {
     COM_assertion( is_real_node( vID));
     Edge_ID eID = _ieIDs_real_or_str[ vID-1]; 
 
     if ( eID.is_border() && eID.eid()<=int(_beIDs.size()) &&
          eID.eid()>_size_real_borders+_size_rg_borders) {
       // If vID is between real and ghost, and on the ghost boundary,
       // get the border edge between real and ghost.
       Edge_ID eID0 = eID = get_opposite_ghost_edge_border( eID);
       while ( (eID = get_opposite_ghost_edge_interior
                ( get_next_ghost_edge_interior(eID))) != eID0 &&
               !is_real_border_edge( eID));
       COM_assertion_msg( eID.is_border() && get_origin( eID)==vID,
                          "No real edge incident on given vertex"); 
     }
 
     return eID;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

Edge_ID get_next_edge ( const Edge_ID & eID ) const

inline

Get the ID of the next edge of the element or along the boundary.

Definition at line 314 of file Simple_manifold_2.h.

References get_next_edge_interior(), get_opposite_edge_border(), get_opposite_edge_interior(), get_prev_edge_interior(), and Facet_ID::is_border().

Referenced by Pane_manifold_2::get_next_edge().

                                                    {
     if ( !eID.is_border()) 
       return get_next_edge_interior( eID);
     else {
       Edge_ID oeID = get_opposite_edge_border( eID);
       while ( !oeID.is_border()) 
         oeID = get_opposite_edge_interior( get_prev_edge_interior( oeID));
       return oeID;
     }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

Edge_ID get_next_edge_interior ( const Edge_ID & eID ) const

inlineprivate

Definition at line 811 of file Simple_manifold_2.h.

References _is_str, _maxsize_real_elmts, _nspe, _oeIDs_ghost, _oeIDs_real_or_str, Facet_ID::eid(), get_edge_index(), i, is_ghost_element(), and Facet_ID::lid().

Referenced by get_next_edge().

                                                             {
     // If not a border edge, then track it within an element.
     int i=eID.lid()+1;
     if ( i>=_nspe) return Edge_ID( eID.eid(), 0);
 
     if ( _is_str || !is_ghost_element( eID.eid())) {
       int eindex = get_edge_index( Edge_ID(eID.eid(), i));
       if ( _oeIDs_real_or_str[eindex]==Edge_ID()) i=0;
     }
     else {
       int eindex = get_edge_index( Edge_ID(eID.eid(), i), _maxsize_real_elmts);
       if ( _oeIDs_ghost[eindex]==Edge_ID()) i=0;
     }
     return Edge_ID( eID.eid(), i);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

Edge_ID get_next_ghost_edge ( const Edge_ID & eID ) const

inline

Get the ID of the next ghost edge of the element or along the boundary.

Definition at line 339 of file Simple_manifold_2.h.

References get_next_ghost_edge_interior(), get_opposite_ghost_edge(), get_opposite_ghost_edge_interior(), get_prev_ghost_edge_interior(), and Facet_ID::is_border().

                                                          {
     if ( !eID.is_border()) 
       return get_next_ghost_edge_interior( eID);
     else {
       Edge_ID oeID = get_opposite_ghost_edge( eID);
       while ( !oeID.is_border()) 
         oeID = get_opposite_ghost_edge_interior
           ( get_prev_ghost_edge_interior( oeID));
       return oeID;
     }
   }

Here is the call graph for this function:

Edge_ID get_next_ghost_edge_interior ( const Edge_ID & eID ) const

inlineprivate

Definition at line 840 of file Simple_manifold_2.h.

References _is_str, _maxsize_real_elmts, _nspe, _oeIDs_ghost, _oeIDs_real_or_str, COM_assertion, Facet_ID::eid(), get_edge_index(), i, is_ghost_element(), and Facet_ID::lid().

Referenced by get_incident_real_edge(), get_next_ghost_edge(), and get_prev_ghost_edge().

                                                                   {
     COM_assertion( is_ghost_element( eID.eid()));
 
     // If not a border edge, then track it within an element.
     int i=eID.lid()+1;
     if ( i>=_nspe) return Edge_ID( eID.eid(), 0);
 
     if ( _is_str) {
       int eindex = get_edge_index( Edge_ID(eID.eid(), i));
       if ( _oeIDs_real_or_str[eindex]==Edge_ID()) i=0;
     }
     else {
       int eindex = get_edge_index( Edge_ID(eID.eid(), i), _maxsize_real_elmts);
       if ( _oeIDs_ghost[eindex]==Edge_ID()) i=0;
     }
     return Edge_ID( eID.eid(), i);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

Edge_ID get_next_real_edge ( const Edge_ID & eID ) const

inline

Get the ID of the next real edge of the element or along the boundary.

Definition at line 326 of file Simple_manifold_2.h.

References get_next_real_edge_interior(), get_opposite_real_edge(), get_opposite_real_edge_interior(), get_prev_real_edge_interior(), and Facet_ID::is_border().

Referenced by Pane_manifold_2::get_next_edge().

                                                         {
     if ( !eID.is_border()) 
       return get_next_real_edge_interior( eID);
     else {
       Edge_ID oeID = get_opposite_real_edge( eID);
       while ( !oeID.is_border()) 
         oeID = get_opposite_real_edge_interior
           ( get_prev_real_edge_interior( oeID));
       return oeID;
     }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

Edge_ID get_next_real_edge_interior ( const Edge_ID & eID ) const

inlineprivate

Definition at line 827 of file Simple_manifold_2.h.

References _nspe, _oeIDs_real_or_str, COM_assertion, Facet_ID::eid(), get_edge_index(), i, is_ghost_element(), and Facet_ID::lid().

Referenced by get_incident_ghost_edge(), get_next_real_edge(), and get_prev_real_edge().

                                                                  {
     COM_assertion( !is_ghost_element( eID.eid()));
 
     // If not a border edge, then track it within an element.
     int i=eID.lid()+1;
     if ( i>=_nspe) return Edge_ID( eID.eid(), 0);
 
     int eindex = get_edge_index( Edge_ID(eID.eid(), i));
     if ( _oeIDs_real_or_str[eindex]==Edge_ID()) i=0;
 
     return Edge_ID( eID.eid(), i);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

Edge_ID get_opposite_edge ( const Edge_ID & eID ) const

inline

Get the ID of the opposite edge of a given interior or border edge.

If its opposite is a border edge, it returns a border edge ID.

Definition at line 263 of file Simple_manifold_2.h.

References get_opposite_edge_border(), get_opposite_edge_interior(), and Facet_ID::is_border().

Referenced by Pane_manifold_2::get_opposite_edge().

                                                        {
 
     if ( eID.is_border()) 
       return get_opposite_edge_border(eID);
     else 
       return get_opposite_edge_interior(eID);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

Edge_ID get_opposite_edge_border ( const Edge_ID & eID ) const

inlineprivate

Get the opposite edge of a border edge for the whole pane.

Definition at line 726 of file Simple_manifold_2.h.

References _beIDs, _size_real_borders, _size_rg_borders, COM_assertion, Facet_ID::eid(), and Facet_ID::is_border().

Referenced by get_next_edge(), and get_opposite_edge().

                                                                      {
     // Precondition: eID is a border edge of the whole pane
     COM_assertion( eID.is_border() && eID.eid()<=int(_beIDs.size()) &&
                    (eID.eid()<=_size_real_borders ||
                     eID.eid()>_size_real_borders+_size_rg_borders));
 
     return _beIDs[ eID.eid()-1]; 
   }

Here is the call graph for this function:

Here is the caller graph for this function:

Edge_ID get_opposite_edge_interior ( const Edge_ID & eID ) const

inlineprivate

Get the opposite edge of an interior edge of the whole pane.

Definition at line 682 of file Simple_manifold_2.h.

Referenced by get_next_edge(), and get_opposite_edge().

                                                                        { 
     COM_assertion( !eID.is_border());
 
     if ( _is_str || !is_ghost_element( eID.eid())) {
       return _oeIDs_real_or_str[ get_edge_index( eID)];
     }
     else {
       Edge_ID opp;
       opp = _oeIDs_ghost[ get_edge_index(eID,_maxsize_real_elmts)];
 
       if ( !opp.is_border() || opp.eid()>_size_rg_borders+_size_real_borders)
         return opp;
       else {
         Edge_ID opp2 = _beIDs[ opp.eid()-1];
         COM_assertion( opp2 != eID);
         return opp2;
       }
     }
   }

Here is the caller graph for this function:

Edge_ID get_opposite_ghost_edge ( const Edge_ID & eID ) const

inline

Get the ID of the opposite ghost edge of a given real or border edge.

If its opposite is a border edge, it returns a border edge ID.

Definition at line 252 of file Simple_manifold_2.h.

References COM_assertion, Facet_ID::eid(), get_opposite_ghost_edge_border(), get_opposite_ghost_edge_interior(), Facet_ID::is_border(), and is_ghost_element().

Referenced by get_next_ghost_edge(), and get_prev_ghost_edge().

                                                              { 
     COM_assertion( eID.is_border() || is_ghost_element( eID.eid()));
 
     if ( eID.is_border()) 
       return get_opposite_ghost_edge_border(eID);
     else 
       return get_opposite_ghost_edge_interior(eID);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

Edge_ID get_opposite_ghost_edge_border ( const Edge_ID & eID ) const

inlineprivate

Get the opposite edge of a border edge for the ghost pane.

Definition at line 749 of file Simple_manifold_2.h.

References _beIDs, _oeIDs_real_or_str, _size_real_borders, COM_assertion, Facet_ID::eid(), get_edge_index(), Facet_ID::is_border(), and is_real_element().

Referenced by get_destination(), get_incident_real_edge(), and get_opposite_ghost_edge().

                                                                            { 
     // Precondition: eID is a border edge
     COM_assertion( eID.is_border() && eID.eid()>_size_real_borders &&
                    eID.eid()<=int(_beIDs.size()));
 
     Edge_ID opp = _beIDs[ eID.eid()-1]; 
 
     if ( is_real_element( opp.eid())) {
       opp = _oeIDs_real_or_str[ get_edge_index(opp)];
       COM_assertion( opp != eID);
     }
     return opp;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

Edge_ID get_opposite_ghost_edge_interior ( const Edge_ID & eID ) const

inlineprivate

Get the opposite edge of an interior edge of the ghost part.

Definition at line 716 of file Simple_manifold_2.h.

References _is_str, _maxsize_real_elmts, _oeIDs_ghost, _oeIDs_real_or_str, COM_assertion, Facet_ID::eid(), get_edge_index(), Facet_ID::is_border(), and is_ghost_element().

Referenced by determine_incident_halfedges(), get_incident_real_edge(), get_next_ghost_edge(), get_opposite_ghost_edge(), get_opposite_real_edge_interior(), and get_prev_ghost_edge().

                                                                              {
     COM_assertion( !eID.is_border() && is_ghost_element( eID.eid()));
 
     if ( _is_str)
       return _oeIDs_real_or_str[ get_edge_index(eID)]; 
     else
       return _oeIDs_ghost[ get_edge_index(eID,_maxsize_real_elmts)];
   }

Here is the call graph for this function:

Here is the caller graph for this function:

Edge_ID get_opposite_real_edge ( const Edge_ID & eID ) const

inline

Get the ID of the opposite real edge of a given real or border edge.

If its opposite is a border edge, it returns a border edge ID.

Definition at line 241 of file Simple_manifold_2.h.

Referenced by Pane_manifold_2::convert_pconn_edge2ghost(), Window_manifold_2::determine_counterparts(), get_next_real_edge(), Pane_manifold_2::get_opposite_edge(), and get_prev_real_edge().

                                                             {
     COM_assertion( eID.is_border() || is_real_element( eID.eid()));
 
     if ( eID.is_border())
       return get_opposite_real_edge_border(eID);
     else 
       return get_opposite_real_edge_interior(eID);
   }

Here is the caller graph for this function:

Edge_ID get_opposite_real_edge_border ( const Edge_ID & eID ) const

inlineprivate

Get the opposite edge of a border edge for the real pane.

Definition at line 736 of file Simple_manifold_2.h.

References _beIDs, _size_real_borders, _size_rg_borders, COM_assertion, Facet_ID::eid(), Facet_ID::is_border(), and is_real_element().

Referenced by get_destination(), and get_incident_ghost_edge().

                                                                           {
     // Precondition: eID is a border edge
     COM_assertion( eID.is_border() && 
                    eID.eid()<=_size_real_borders+_size_rg_borders);
     
     Edge_ID opp = _beIDs[ eID.eid()-1];
     
     // Postcondition: opp is incident on a real element.
     COM_assertion( is_real_element( opp.eid()));
     return opp;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

Edge_ID get_opposite_real_edge_interior ( const Edge_ID & eID ) const

inlineprivate

Get the opposite edge of an interior edge of the real part.

Definition at line 703 of file Simple_manifold_2.h.

References _oeIDs_real_or_str, COM_assertion, Facet_ID::eid(), get_edge_index(), get_opposite_ghost_edge_interior(), Facet_ID::is_border(), is_ghost_element(), and is_real_element().

Referenced by determine_incident_halfedges(), get_incident_ghost_edge(), get_next_real_edge(), and get_prev_real_edge().

                                                                             {
     COM_assertion( !eID.is_border() && is_real_element( eID.eid()));
 
     Edge_ID opp = _oeIDs_real_or_str[ get_edge_index(eID)]; 
 
     // If points to a ghost element, then we need to follow the link
     if ( !opp.is_border() && is_ghost_element( opp.eid()))
       opp = get_opposite_ghost_edge_interior( opp);
 
     return opp;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

int get_origin	(	Edge_ID	eID,
		Element_node_enumerator *	ene_in = `NULL`
	)		const

inline

Get the ID of the origin of a given edge.

If the edge is between real and ghost, then consider the border edge as part of real.

Definition at line 357 of file Simple_manifold_2.h.

Referenced by determine_incident_halfedges(), get_a_border_node(), get_a_ghost_border_node(), get_a_real_border_node(), get_incident_edge(), get_incident_real_edge(), and Halfedge::origin().

                                                                             {
     if ( eID.is_border()) {
       Edge_ID opp;
       if (is_real_border_edge( eID)) opp = get_opposite_real_edge_border( eID);
       else opp = get_opposite_ghost_edge_border( eID);
 
       Element_node_enumerator ene( _pane, opp.eid());
       return ene[opp.lid()+1==ene.size_of_edges()?0:opp.lid()+1];
     }
     else {
       if ( ene_in) 
         return (*ene_in)[eID.lid()];
       else 
         return Element_node_enumerator( _pane, eID.eid())[eID.lid()];
     }
   }

Here is the caller graph for this function:

Edge_ID get_prev_edge ( const Edge_ID & eID ) const

inline

Get the ID of the previous edge of the element or along the boundary.

Definition at line 276 of file Simple_manifold_2.h.

Referenced by Pane_manifold_2::get_prev_edge().

                                                    {
     if ( !eID.is_border()) 
       return get_prev_edge_interior( eID);
     else {
       Edge_ID oeID = get_opposite_edge( eID);
       while ( !oeID.is_border()) 
         oeID = get_opposite_edge_interior( get_next_edge_interior( oeID));
       return oeID;
     }
   }

Here is the caller graph for this function:

Edge_ID get_prev_edge_interior ( const Edge_ID & eID ) const

inlineprivate

Definition at line 767 of file Simple_manifold_2.h.

References _is_str, _maxsize_real_elmts, _nspe, _oeIDs_ghost, _oeIDs_real_or_str, Facet_ID::eid(), get_edge_index(), i, is_ghost_element(), and Facet_ID::lid().

Referenced by get_next_edge().

                                                             {
     // If not a border edge, then track it within an element.
     int i=(eID.lid()?eID.lid()-1:_nspe-1);
 
     if ( _is_str || !is_ghost_element( eID.eid())) {
       int eindex = get_edge_index( Edge_ID(eID.eid(), i));
       while ( _oeIDs_real_or_str[eindex--]==Edge_ID()) { --i; assert(i); }
     }
     else {
       int eindex = get_edge_index( Edge_ID(eID.eid(), i), _maxsize_real_elmts);
       while ( _oeIDs_ghost[eindex--]==Edge_ID()) { --i; assert(i); }
     }
     return Edge_ID( eID.eid(), i);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

Edge_ID get_prev_ghost_edge ( const Edge_ID & eID ) const

inline

Get the ID of the previous ghost edge of the element or along the boundary.

Definition at line 301 of file Simple_manifold_2.h.

References get_next_ghost_edge_interior(), get_opposite_ghost_edge(), get_opposite_ghost_edge_interior(), get_prev_ghost_edge_interior(), and Facet_ID::is_border().

                                                          {
     if ( !eID.is_border()) 
       return get_prev_ghost_edge_interior(eID);
     else {
       Edge_ID oeID = get_opposite_ghost_edge( eID);
       while ( !oeID.is_border()) 
         oeID = get_opposite_ghost_edge_interior
           ( get_next_ghost_edge_interior( oeID));
       return oeID;
     }
   }

Here is the call graph for this function:

Edge_ID get_prev_ghost_edge_interior ( const Edge_ID & eID ) const

inlineprivate

Definition at line 794 of file Simple_manifold_2.h.

References _is_str, _maxsize_real_elmts, _nspe, _oeIDs_ghost, _oeIDs_real_or_str, COM_assertion, Facet_ID::eid(), get_edge_index(), i, is_ghost_element(), and Facet_ID::lid().

Referenced by get_next_ghost_edge(), and get_prev_ghost_edge().

                                                                   {
     COM_assertion( is_ghost_element( eID.eid()));
 
     // If not a border edge, then track it within an element.
     int i=(eID.lid()?eID.lid()-1:_nspe-1);
 
     if ( _is_str) {
       int eindex = get_edge_index( Edge_ID(eID.eid(), i));
       while ( _oeIDs_real_or_str[eindex--]==Edge_ID()) { --i; assert(i); }
     }
     else {
       int eindex = get_edge_index( Edge_ID(eID.eid(), i), _maxsize_real_elmts);
       while ( _oeIDs_ghost[eindex--]==Edge_ID()) { --i; assert(i); }
     }
     return Edge_ID( eID.eid(), i);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

Edge_ID get_prev_real_edge ( const Edge_ID & eID ) const

inline

Get the ID of the previous real edge of the element or along the boundary.

Definition at line 288 of file Simple_manifold_2.h.

References get_next_real_edge_interior(), get_opposite_real_edge(), get_opposite_real_edge_interior(), get_prev_real_edge_interior(), and Facet_ID::is_border().

Referenced by Pane_manifold_2::get_prev_edge().

                                                         {
     if ( !eID.is_border()) 
       return get_prev_real_edge_interior( eID);
     else {
       Edge_ID oeID = get_opposite_real_edge( eID);
       while ( !oeID.is_border()) 
         oeID = get_opposite_real_edge_interior
           ( get_next_real_edge_interior( oeID));
       return oeID;
     }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

Edge_ID get_prev_real_edge_interior ( const Edge_ID & eID ) const

inlineprivate

Definition at line 782 of file Simple_manifold_2.h.

References _nspe, _oeIDs_real_or_str, COM_assertion, Facet_ID::eid(), get_edge_index(), i, is_ghost_element(), and Facet_ID::lid().

Referenced by get_next_real_edge(), and get_prev_real_edge().

                                                                  {
     COM_assertion( !is_ghost_element( eID.eid()));
 
     // If not a border edge, then track it within an element.
     int i=(eID.lid()?eID.lid()-1:_nspe-1);
 
     int eindex = get_edge_index( Edge_ID(eID.eid(), i));
     while ( _oeIDs_real_or_str[eindex--]==Edge_ID()) { --i; assert(i); }
 
     return Edge_ID( eID.eid(), i);   
   }

Here is the call graph for this function:

Here is the caller graph for this function:

MAP_BEGIN_NAMESPACE void init	(	const COM::Pane *	p,
		const Simple_manifold_2 *	parent = `NULL`,
		bool	with_ghost = `true`
	)

protected

Initialize the database for the pane, including ghost information, opposite halfedges, incident halfedges, and border halfedges.

Typically called by constructors.

Definition at line 31 of file Simple_manifold_2.C.

References _beIDs, _elem_conns, _ieIDs_ghost, _ieIDs_real_or_str, _is_str, _isghostelmt, _isghostnode, _isovIDs, _maxsize_real_elmts, _maxsize_real_nodes, _nspe, _oeIDs_ghost, _oeIDs_real_or_str, _pane, _with_ghost, COM_assertion_msg, determine_ghosts(), determine_incident_halfedges(), determine_opposite_halfedges(), i, and max().

Referenced by Simple_manifold_2().

                                                {
   COM_assertion_msg( p, "Caught NULL pointer");
   _pane = p;
   _is_str = p->is_structured();
 
   // Initialize _nspe to 4 for structured or mixed meshes and to the
   // actual number of edges per element for other type of meshes.
   if ( _is_str) {
     _with_ghost = with_ghost && p->size_of_ghost_layers()>0;
     _nspe = 4;
   }
   else {
     // It is possible to have ghost nodes but no ghost elements and vice versa
     _with_ghost = with_ghost && 
       (p->size_of_ghost_nodes()>0 || p->size_of_ghost_elements()>0);
 
     p->elements( _elem_conns);
     _nspe = 0;
     // Loop through the connectivity
     for ( int i=_elem_conns.size()-1; i>=0; --i) {
       _nspe = std::max( _nspe, int( _elem_conns[i]->size_of_edges_pe()));
     }
   }
 
   _maxsize_real_nodes = p->maxsize_of_real_nodes();
   _maxsize_real_elmts = p->maxsize_of_real_elements();
 
   if ( parent) {
     _isghostnode = parent->_isghostnode;
     _isghostelmt = parent->_isghostelmt;
 
     // Copy border infomation from parent
     _oeIDs_real_or_str = parent->_oeIDs_real_or_str;
     _oeIDs_ghost = parent->_oeIDs_ghost;
     _ieIDs_real_or_str = parent->_ieIDs_real_or_str;
     _ieIDs_ghost = parent->_ieIDs_ghost;
 
     _beIDs = parent->_beIDs;
     _isovIDs = parent->_isovIDs;
   }
   else {
     determine_ghosts();
     determine_opposite_halfedges();
     determine_incident_halfedges();
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool is_border_edge ( const Edge_ID & eID ) const

inline

Is a given edge on the boundary of the whole pane?

Definition at line 468 of file Simple_manifold_2.h.

Referenced by determine_incident_halfedges(), and is_border_node().

                                                  { 
     if ( !eID.is_border()) return false;
     if ( eID.eid()>int(_beIDs.size())) return false;
 
     return !_with_ghost || eID.eid() <= _size_real_borders ||
       eID.eid() > _size_real_borders+_size_rg_borders;
   }

Here is the caller graph for this function:

bool is_border_node ( int vID ) const

inline

Is the node on pane boundary (not isolated)?

Definition at line 535 of file Simple_manifold_2.h.

References _ieIDs_ghost, _ieIDs_real_or_str, _is_str, _maxsize_real_nodes, is_border_edge(), and is_ghost_node().

Referenced by get_borders().

                                        { 
     Edge_ID eID;
     if ( _is_str || !is_ghost_node( vID))
       eID = _ieIDs_real_or_str[ vID-1]; 
     else
       eID = _ieIDs_ghost[ vID-_maxsize_real_nodes-1];
 
     return is_border_edge( eID);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

bool is_ghost_border_edge ( const Edge_ID & eID ) const

inline

Determine whether a given edge is a border edge of ghost part of the pane (either on physical border or between real and ghost elements)

Definition at line 494 of file Simple_manifold_2.h.

References _beIDs, _size_real_borders, _with_ghost, Facet_ID::eid(), and Facet_ID::is_border().

Referenced by get_incident_ghost_edge().

                                                          {
     if ( !eID.is_border()) return false;
     if ( eID.eid()>int(_beIDs.size())) return false;
 
     return _with_ghost && eID.eid() > _size_real_borders;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

bool is_ghost_border_node ( int vID ) const

inline

Is the node on pane boundary (not isolated)? It assumes vID is incident on the ghost (no checking is performed).

Definition at line 524 of file Simple_manifold_2.h.

References _beIDs, _ieIDs_ghost, _ieIDs_real_or_str, _is_str, _maxsize_real_nodes, Facet_ID::eid(), Facet_ID::is_border(), and is_ghost_node().

                                             { 
     Edge_ID eID;
     if ( _is_str || !is_ghost_node( vID))
       eID = _ieIDs_real_or_str[ vID-1]; 
     else
       eID = _ieIDs_ghost[ vID-_maxsize_real_nodes-1];
 
     return eID.is_border() && eID.eid() <= int(_beIDs.size()); 
   }

Here is the call graph for this function:

bool is_ghost_element ( int eid ) const

inline

Is the element incident on the give edge a ghost element?

Definition at line 631 of file Simple_manifold_2.h.

References _is_str, _isghostelmt, and _maxsize_real_elmts.

Referenced by determine_opposite_halfedges(), get_next_edge_interior(), get_next_ghost_edge_interior(), get_next_real_edge_interior(), get_opposite_ghost_edge(), get_opposite_ghost_edge_interior(), get_opposite_real_edge_interior(), get_prev_edge_interior(), get_prev_ghost_edge_interior(), and get_prev_real_edge_interior().

                                          {
     if ( !_is_str) // Unstructured mesh
       return eid > _maxsize_real_elmts;
     else // Structured
       return !_isghostelmt.empty() && _isghostelmt[ eid-1]; 
   }

Here is the caller graph for this function:

bool is_ghost_node ( int vID ) const

inline

Is the given node a ghost node?

Definition at line 615 of file Simple_manifold_2.h.

References _is_str, _isghostnode, and _maxsize_real_nodes.

Referenced by get_incident_edge(), get_incident_ghost_edge(), is_border_node(), is_ghost_border_node(), and is_real_border_node().

                                      {
     if ( !_is_str) // Unstructured mesh
       return vID > _maxsize_real_nodes;
     else // Structured mesh
       return !_isghostnode.empty() && _isghostnode[ vID-1]; 
   }

Here is the caller graph for this function:

bool is_isolated_node ( int vID ) const

inline

Is the node isolated (i.e. not incident on any element)?

Definition at line 502 of file Simple_manifold_2.h.

References _beIDs, _ieIDs_real_or_str, _is_str, _maxsize_real_nodes, Facet_ID::eid(), and Facet_ID::is_border().

Referenced by get_borders(), and Node::is_isolated().

                                         {
     // Ghost nodes are not allowed to be isolated.
     if ( _is_str || vID>_maxsize_real_nodes) return false;
 
     Edge_ID eID = _ieIDs_real_or_str[ vID-1];
     return eID.is_border() && eID.eid()>int(_beIDs.size());
   }

Here is the call graph for this function:

Here is the caller graph for this function:

bool is_pure_real_border_edge ( const Edge_ID & eID ) const

inline

Determine whether a given edge is a border edge of real part of the whole pane (on physical border).

Definition at line 478 of file Simple_manifold_2.h.

References _size_real_borders, _with_ghost, Facet_ID::eid(), and Facet_ID::is_border().

Referenced by Pane_manifold_2::is_border_edge().

                                                             {
     if ( !eID.is_border()) return false;
 
     return !_with_ghost || eID.eid() <= _size_real_borders;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

bool is_real_border_edge ( const Edge_ID & eID ) const

inline

Determine whether a given edge is a border edge of real part of the pane (either on physical border or between real and ghost elements)

Definition at line 486 of file Simple_manifold_2.h.

References _size_real_borders, _size_rg_borders, _with_ghost, Facet_ID::eid(), and Facet_ID::is_border().

Referenced by get_destination(), get_incident_real_edge(), Pane_manifold_2::get_next_edge(), and Pane_manifold_2::is_border_edge().

                                                        {
     if ( !eID.is_border()) return false;
 
     return !_with_ghost || eID.eid() <= _size_real_borders+_size_rg_borders;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

bool is_real_border_node ( int vID ) const

inline

Is the node on the pane boundary of real part (not isolated)?

Definition at line 511 of file Simple_manifold_2.h.

References _beIDs, _ieIDs_ghost, _ieIDs_real_or_str, _is_str, _maxsize_real_nodes, Facet_ID::eid(), Facet_ID::is_border(), is_ghost_node(), and is_real_node().

Referenced by get_borders().

                                            { 
     if ( !is_real_node( vID)) return false;
     Edge_ID eID;
     if ( _is_str || !is_ghost_node( vID))
       eID = _ieIDs_real_or_str[ vID-1]; 
     else
       eID = _ieIDs_ghost[ vID-_maxsize_real_nodes-1];
 
     return eID.is_border() && eID.eid() <= int(_beIDs.size()); 
   }

Here is the call graph for this function:

Here is the caller graph for this function:

bool is_real_element ( int eid ) const

inline

Is the element incident on the give edge a real element?

Definition at line 623 of file Simple_manifold_2.h.

References _is_str, _isghostelmt, and _maxsize_real_elmts.

Referenced by determine_incident_halfedges(), determine_opposite_halfedges(), get_opposite_ghost_edge_border(), get_opposite_real_edge_border(), and get_opposite_real_edge_interior().

                                         {
     if ( !_is_str) // Unstructured mesh
       return eid <= _maxsize_real_elmts;
     else // Structured mesh 
       return _isghostelmt.empty() || !_isghostelmt[ eid-1]; 
   }

Here is the caller graph for this function:

bool is_real_node ( int vID ) const

inline

Is the given node a real node?

Definition at line 607 of file Simple_manifold_2.h.

References _is_str, _isghostnode, and _maxsize_real_nodes.

Referenced by determine_incident_halfedges(), get_incident_real_edge(), and is_real_border_node().

                                     {
     if ( !_is_str) // Unstructured mesh
       return vID <= _maxsize_real_nodes;
     else // Structured mesh
       return _isghostnode.empty() || !_isghostnode[ vID-1]; 
   }

Here is the caller graph for this function:

int maxsize_of_elements ( ) const

inline

Maximum number of elements allowed in the pane.

Definition at line 127 of file Simple_manifold_2.h.

References _pane.

127 { return _pane->maxsize_of_elements(); }

Simple_manifold_2::_pane

const COM::Pane * _pane

Definition: Simple_manifold_2.h:860

int maxsize_of_faces ( ) const

inline

Maximum number of elements allowed in the pane.

Definition at line 145 of file Simple_manifold_2.h.

References _pane.

145 { return _pane->maxsize_of_elements(); }

Simple_manifold_2::_pane

const COM::Pane * _pane

Definition: Simple_manifold_2.h:860

int maxsize_of_ghost_elements ( ) const

inline

Maximum number of ghost elements allowed in the pane.

Definition at line 139 of file Simple_manifold_2.h.

References _pane.

139 { return _pane->maxsize_of_ghost_elements(); }

Simple_manifold_2::_pane

const COM::Pane * _pane

Definition: Simple_manifold_2.h:860

int maxsize_of_ghost_faces ( ) const

inline

Maximum number of ghost elements allowed in the pane.

Definition at line 157 of file Simple_manifold_2.h.

References _pane.

157 { return _pane->maxsize_of_ghost_elements(); }

Simple_manifold_2::_pane

const COM::Pane * _pane

Definition: Simple_manifold_2.h:860

int maxsize_of_ghost_nodes ( ) const

inline

Maximum number of ghost nodes allowed in the pane.

Definition at line 118 of file Simple_manifold_2.h.

References _pane.

118 { return _pane->maxsize_of_ghost_nodes();}

Simple_manifold_2::_pane

const COM::Pane * _pane

Definition: Simple_manifold_2.h:860

int maxsize_of_ghost_quadrilaterals ( ) const

Maximum number of ghost quadrilaterals allowed in the pane.

int maxsize_of_ghost_triangles ( ) const

Maximum number of ghost triangles allowed in the pane.

int maxsize_of_nodes ( ) const

inline

Maximum number of nodes allowed in the pane.

Definition at line 106 of file Simple_manifold_2.h.

References _pane.

106 { return _pane->maxsize_of_nodes(); }

Simple_manifold_2::_pane

const COM::Pane * _pane

Definition: Simple_manifold_2.h:860

int maxsize_of_quadrilaterals ( ) const

Maximum number of quadrilaterals allowed in the pane.

int maxsize_of_real_elements ( ) const

inline

Maximum number of real elements allowed in the pane.

Definition at line 133 of file Simple_manifold_2.h.

References _maxsize_real_elmts.

133 { return _maxsize_real_elmts; }

Simple_manifold_2::_maxsize_real_elmts

int _maxsize_real_elmts

Definition: Simple_manifold_2.h:870

int maxsize_of_real_faces ( ) const

inline

Maximum number of real elements allowed in the pane.

Definition at line 151 of file Simple_manifold_2.h.

References _pane.

151 { return _pane->maxsize_of_real_elements(); }

Simple_manifold_2::_pane

const COM::Pane * _pane

Definition: Simple_manifold_2.h:860

int maxsize_of_real_nodes ( ) const

inline

Maximum number of real nodes allowed in the pane.

Definition at line 112 of file Simple_manifold_2.h.

References _maxsize_real_nodes.

112 { return _maxsize_real_nodes; }

Simple_manifold_2::_maxsize_real_nodes

int _maxsize_real_nodes

Definition: Simple_manifold_2.h:869

int maxsize_of_real_quadrilaterals ( ) const

Maximum number of real quadrilaterals allowed in the pane.

int maxsize_of_real_triangles ( ) const

Maximum number of real triangles allowed in the pane.

int maxsize_of_triangles ( ) const

Maximum number of triangles allowed in the pane.

const COM::Pane* pane ( ) const

inline

Obtain a const pointer to the pane.

Definition at line 97 of file Simple_manifold_2.h.

References _pane.

Referenced by Node::addr(), Halfedge::addr(), Node::attr(), Halfedge::attr(), Window_manifold_2::determine_counterparts(), Halfedge::edge_center(), Halfedge::face_center(), Node::operator<(), Halfedge::operator<(), Node::pane(), Halfedge::pane(), and Node::point().

97 { return _pane; }

Simple_manifold_2::_pane

const COM::Pane * _pane

Definition: Simple_manifold_2.h:860

Here is the caller graph for this function:

int size_of_border_edges ( ) const

inline

Number of border edges of the whole pane.

Definition at line 220 of file Simple_manifold_2.h.

221 { return _size_real_borders + _size_ghost_borders; }

Simple_manifold_2::_size_ghost_borders

int _size_ghost_borders

Definition: Simple_manifold_2.h:873

Simple_manifold_2::_size_real_borders

int _size_real_borders

Definition: Simple_manifold_2.h:872

int size_of_edges ( ) const

Number of edges of the pane.

Referenced by Pane_manifold_2::size_of_edges().

Here is the caller graph for this function:

int size_of_elements ( ) const

inline

Number of elements of the pane.

Definition at line 124 of file Simple_manifold_2.h.

Referenced by upperbound_edge_index().

124 { return _pane->size_of_elements(); }

Simple_manifold_2::_pane

const COM::Pane * _pane

Definition: Simple_manifold_2.h:860

Here is the caller graph for this function:

int size_of_faces ( ) const

inline

Number of elements of the pane.

Definition at line 142 of file Simple_manifold_2.h.

References _pane.

Referenced by Pane_manifold_2::size_of_faces().

142 { return _pane->size_of_elements(); }

Simple_manifold_2::_pane

const COM::Pane * _pane

Definition: Simple_manifold_2.h:860

Here is the caller graph for this function:

int size_of_ghost_border_edges ( ) const

inline

Number of border edges of the ghost part of the pane.

Definition at line 228 of file Simple_manifold_2.h.

References _size_ghost_borders, and _size_rg_borders.

229 { return _size_ghost_borders + _size_rg_borders; }

Simple_manifold_2::_size_ghost_borders

int _size_ghost_borders

Definition: Simple_manifold_2.h:873

Simple_manifold_2::_size_rg_borders

int _size_rg_borders

Definition: Simple_manifold_2.h:874

int size_of_ghost_edges ( ) const

Number of ghost edges of the pane.

int size_of_ghost_elements ( ) const

inline

Number of ghost elements of the pane.

Definition at line 136 of file Simple_manifold_2.h.

References _pane.

136 { return _pane->size_of_ghost_elements(); }

Simple_manifold_2::_pane

const COM::Pane * _pane

Definition: Simple_manifold_2.h:860

int size_of_ghost_faces ( ) const

inline

Number of ghost elements of the pane.

Definition at line 154 of file Simple_manifold_2.h.

References _pane.

154 { return _pane->size_of_ghost_elements(); }

Simple_manifold_2::_pane

const COM::Pane * _pane

Definition: Simple_manifold_2.h:860

int size_of_ghost_halfedges ( ) const

Number of ghost halfedges of the pane.

int size_of_ghost_nodes ( ) const

inline

Number of ghost nodes of the pane.

Definition at line 115 of file Simple_manifold_2.h.

References _pane.

Referenced by get_borders().

115 { return _pane->size_of_ghost_nodes(); }

Simple_manifold_2::_pane

const COM::Pane * _pane

Definition: Simple_manifold_2.h:860

Here is the caller graph for this function:

int size_of_ghost_quadrilaterals ( ) const

Number of ghost quadrilaterals of the pane.

int size_of_ghost_triangles ( ) const

Number of ghost triangles of the pane.

int size_of_halfedges ( ) const

Number of halfedges of the pane.

int size_of_isolated_nodes ( ) const

inline

Number of isolated nodes.

Definition at line 232 of file Simple_manifold_2.h.

References _isovIDs.

233 { return _isovIDs.size(); }

Simple_manifold_2::_isovIDs

std::vector< int > _isovIDs

Definition: Simple_manifold_2.h:901

int size_of_nodes ( ) const

inline

Number of nodes of the pane.

Definition at line 103 of file Simple_manifold_2.h.

Referenced by Pane_manifold_2::size_of_nodes().

103 { return _pane->size_of_nodes(); }

Simple_manifold_2::_pane

const COM::Pane * _pane

Definition: Simple_manifold_2.h:860

Here is the caller graph for this function:

int size_of_quadrilaterals ( ) const

Total number of quadrilaterals of the pane.

Referenced by Pane_manifold_2::size_of_quadrilaterals().

Here is the caller graph for this function:

int size_of_real_border_edges ( ) const

inline

Number of border edges of the real part of the pane.

Definition at line 224 of file Simple_manifold_2.h.

References _size_real_borders, and _size_rg_borders.

Referenced by Pane_manifold_2::convert_pconn_edge2ghost().

225 { return _size_real_borders + _size_rg_borders; }

Simple_manifold_2::_size_real_borders

int _size_real_borders

Definition: Simple_manifold_2.h:872

Simple_manifold_2::_size_rg_borders

int _size_rg_borders

Definition: Simple_manifold_2.h:874

Here is the caller graph for this function:

int size_of_real_edges ( ) const

Number of real edges of the pane.

Referenced by Pane_manifold_2::size_of_edges().

Here is the caller graph for this function:

int size_of_real_elements ( ) const

inline

Number of real elements of the pane.

Definition at line 130 of file Simple_manifold_2.h.

References _pane.

130 { return _pane->size_of_real_elements(); }

Simple_manifold_2::_pane

const COM::Pane * _pane

Definition: Simple_manifold_2.h:860

int size_of_real_faces ( ) const

inline

Number of real elements of the pane.

Definition at line 148 of file Simple_manifold_2.h.

References _pane.

Referenced by Pane_manifold_2::size_of_faces().

148 { return _pane->size_of_real_elements(); }

Simple_manifold_2::_pane

const COM::Pane * _pane

Definition: Simple_manifold_2.h:860

Here is the caller graph for this function:

int size_of_real_halfedges ( ) const

Number of real halfedges of the pane.

int size_of_real_nodes ( ) const

inline

Number of real nodes of the pane.

Definition at line 109 of file Simple_manifold_2.h.

References _pane.

Referenced by get_borders(), and Pane_manifold_2::size_of_nodes().

109 { return _pane->size_of_real_nodes(); }

Simple_manifold_2::_pane

const COM::Pane * _pane

Definition: Simple_manifold_2.h:860

Here is the caller graph for this function:

int size_of_real_quadrilaterals ( ) const

Number of real quadrilaterals of the pane.

Referenced by Pane_manifold_2::size_of_quadrilaterals().

Here is the caller graph for this function:

int size_of_real_triangles ( ) const

Number of real triangles of the pane.

Referenced by Pane_manifold_2::size_of_triangles().

Here is the caller graph for this function:

int size_of_triangles ( ) const

Total number of triangles of the pane.

Referenced by Pane_manifold_2::size_of_triangles().

Here is the caller graph for this function:

int upperbound_edge_index ( ) const

inline

Get size of internal edges.

Definition at line 643 of file Simple_manifold_2.h.

References _nspe, and size_of_elements().

644 { return size_of_elements()*_nspe; }

Simple_manifold_2::size_of_elements

int size_of_elements() const

Number of elements of the pane.

Definition: Simple_manifold_2.h:124

Simple_manifold_2::_nspe

int _nspe

Definition: Simple_manifold_2.h:867

Here is the call graph for this function:

Member Data Documentation

std::vector<Edge_ID> _beIDs

protected

Definition at line 898 of file Simple_manifold_2.h.

Referenced by determine_incident_halfedges(), determine_opposite_halfedges(), get_a_border_node(), get_a_ghost_border_node(), get_a_real_border_node(), Pane_manifold_2::get_bnode_index(), get_borders(), get_incident_edge(), get_incident_real_edge(), get_opposite_edge_border(), get_opposite_ghost_edge_border(), get_opposite_real_edge_border(), init(), is_ghost_border_edge(), is_ghost_border_node(), is_isolated_node(), and is_real_border_node().

std::vector<const COM::Connectivity*> _elem_conns

protected

Definition at line 866 of file Simple_manifold_2.h.

Referenced by init().

std::vector<Edge_ID> _ieIDs_ghost

protected

Definition at line 888 of file Simple_manifold_2.h.

Referenced by determine_incident_halfedges(), get_incident_edge(), get_incident_ghost_edge(), init(), is_border_node(), is_ghost_border_node(), and is_real_border_node().

std::vector<Edge_ID> _ieIDs_real_or_str

protected

Definition at line 886 of file Simple_manifold_2.h.

Referenced by determine_incident_halfedges(), get_incident_edge(), get_incident_ghost_edge(), get_incident_real_edge(), init(), is_border_node(), is_ghost_border_node(), is_isolated_node(), and is_real_border_node().

bool _is_str

protected

std::vector<bool> _isghostelmt

protected

Definition at line 877 of file Simple_manifold_2.h.

Referenced by determine_ghosts(), init(), is_ghost_element(), and is_real_element().

std::vector<bool> _isghostnode

protected

Definition at line 876 of file Simple_manifold_2.h.

Referenced by determine_ghosts(), init(), is_ghost_node(), and is_real_node().

std::vector<int> _isovIDs

protected

Definition at line 901 of file Simple_manifold_2.h.

Referenced by determine_incident_halfedges(), init(), and size_of_isolated_nodes().

int _maxsize_real_elmts

protected

Definition at line 870 of file Simple_manifold_2.h.

Referenced by determine_incident_halfedges(), determine_opposite_halfedges(), get_next_edge_interior(), get_next_ghost_edge_interior(), get_opposite_ghost_edge_interior(), get_prev_edge_interior(), get_prev_ghost_edge_interior(), init(), is_ghost_element(), is_real_element(), and maxsize_of_real_elements().

int _maxsize_real_nodes

protected

Definition at line 869 of file Simple_manifold_2.h.

Referenced by determine_incident_halfedges(), get_borders(), get_incident_edge(), get_incident_ghost_edge(), init(), is_border_node(), is_ghost_border_node(), is_ghost_node(), is_isolated_node(), is_real_border_node(), is_real_node(), and maxsize_of_real_nodes().

int _nspe

protected

Definition at line 867 of file Simple_manifold_2.h.

Referenced by determine_opposite_halfedges(), get_edge_index(), get_next_edge_interior(), get_next_ghost_edge_interior(), get_next_real_edge_interior(), get_prev_edge_interior(), get_prev_ghost_edge_interior(), get_prev_real_edge_interior(), init(), and upperbound_edge_index().

std::vector<Edge_ID> _oeIDs_ghost

protected

Definition at line 882 of file Simple_manifold_2.h.

Referenced by determine_opposite_halfedges(), get_next_edge_interior(), get_next_ghost_edge_interior(), get_opposite_ghost_edge_interior(), get_prev_edge_interior(), get_prev_ghost_edge_interior(), and init().

std::vector<Edge_ID> _oeIDs_real_or_str

protected

Definition at line 880 of file Simple_manifold_2.h.

Referenced by determine_opposite_halfedges(), get_incident_edge(), get_next_edge_interior(), get_next_ghost_edge_interior(), get_next_real_edge_interior(), get_opposite_ghost_edge_border(), get_opposite_ghost_edge_interior(), get_opposite_real_edge_interior(), get_prev_edge_interior(), get_prev_ghost_edge_interior(), get_prev_real_edge_interior(), and init().

const COM::Pane* _pane

protected

int _size_ghost_borders

protected

Definition at line 873 of file Simple_manifold_2.h.

Referenced by determine_opposite_halfedges(), get_a_border_edge(), get_a_border_node(), get_a_ghost_border_edge(), get_a_ghost_border_node(), Pane_manifold_2::get_bnode_index(), get_borders(), and size_of_ghost_border_edges().

int _size_real_borders

protected

int _size_rg_borders

protected

Definition at line 874 of file Simple_manifold_2.h.

Referenced by determine_opposite_halfedges(), get_a_border_edge(), get_a_border_node(), get_a_ghost_border_edge(), get_a_ghost_border_node(), get_a_real_border_edge(), get_a_real_border_node(), get_borders(), get_incident_edge(), get_incident_real_edge(), get_opposite_edge_border(), get_opposite_real_edge_border(), is_real_border_edge(), size_of_ghost_border_edges(), and size_of_real_border_edges().

bool _with_ghost

protected

Definition at line 863 of file Simple_manifold_2.h.

Referenced by determine_ghosts(), determine_incident_halfedges(), determine_opposite_halfedges(), get_borders(), init(), is_ghost_border_edge(), is_pure_real_border_edge(), and is_real_border_edge().

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

Public Types

Public Member Functions

Protected Member Functions

Protected Attributes

Opposite Edges

Previous and next Edges

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation