Pane_boundary Class Reference

#include <Pane_boundary.h>

Collaboration diagram for Pane_boundary:

Public Types
typedef int	Node_ID
typedef int	Element_ID
typedef std::pair< Node_ID, Node_ID >	Node_pair

Public Member Functions
	Pane_boundary (const COM::Pane *p)
	Constructors. More...
	Pane_boundary (const Simple_manifold_2 *pm)
	Constructors. More...
void	determine_border_nodes (std::vector< bool > &is_border, std::vector< bool > &is_isolated, std::vector< Facet_ID > *b=NULL, int ghost_level=0) throw (int)
	Determine the border nodes (excluding isolated nodes) More...
double	min_squared_edge_len (const std::vector< Facet_ID > &) throw (int)
	Compute the minimum squared edge length of given edges. More...

Static Public Member Functions
static void	determine_borders (const COM::Attribute *mesh, COM::Attribute *isborder, int ghost_level=0)
	Determine the nodes at pane boundaries of a given mesh. More...

Protected Member Functions
void	determine_border_nodes_3 (std::vector< bool > &is_border, std::vector< Facet_ID > *b, int ghost_level) throw (int)
	Determine the border nodes for a 3-D mesh. More...
void	determine_isolated_nodes (std::vector< bool > &is_isolated, int ghost_level) throw (int)
	Determine the isolated nodes (i.e. not belonging to any element) More...

Private Attributes
const COM::Pane &	_pane
const Simple_manifold_2 *const	_pm

Detailed Description

Definition at line 42 of file Pane_boundary.h.

Member Typedef Documentation

typedef int Element_ID

Definition at line 45 of file Pane_boundary.h.

typedef int Node_ID

Definition at line 44 of file Pane_boundary.h.

typedef std::pair<Node_ID, Node_ID> Node_pair

Definition at line 46 of file Pane_boundary.h.

Constructor & Destructor Documentation

Pane_boundary ( const COM::Pane *  p )

inline

Constructors.

Definition at line 49 of file Pane_boundary.h.

: _pane(*p),_pm(NULL) {}

Pane_boundary ( const Simple_manifold_2 *  pm )

inline

Constructors.

Definition at line 52 of file Pane_boundary.h.

    : _pane(*pm->pane()),_pm(pm) {}

Member Function Documentation

MAP_BEGIN_NAMESPACE void determine_border_nodes	(	std::vector< bool > &	is_border,
		std::vector< bool > &	is_isolated,
		std::vector< Facet_ID > *	b = NULL,
		int	ghost_level = 0
	)
throw	(	int
	)

Determine the border nodes (excluding isolated nodes)

Definition at line 37 of file Pane_boundary.C.

Referenced by determine_borders(), and Pane_connectivity::get_local_boundary_nodes().

                                                    {
  if ( _pane.dimension() == 2) {
    int ng;
    int *ng_ptr = ghost_level ? &ng : (int*)NULL;

    if ( _pm) {
      _pm->get_borders( is_border, is_isolated, b, ng_ptr);
    }
    else
      Simple_manifold_2( &_pane, NULL, ghost_level).
        get_borders( is_border, is_isolated, b, ng_ptr);
  }
  else {
        
    determine_border_nodes_3( is_border, b, ghost_level);
    determine_isolated_nodes( is_isolated, ghost_level);
  }
}

Here is the caller graph for this function:

void determine_border_nodes_3 ( std::vector< bool > &  is_border, std::vector< Facet_ID > *  b, int  ghost_level  ) throw ( int )

protected

Determine the border nodes for a 3-D mesh.

A ghost level of 0 returns all real border nodes A ghost level of 1,2,3 returns the border nodes for the 1st, 2nd, 3rd... ghost layer (structured meshes) A ghost level > 0 returns the border ghost nodes (unstructured meshes)

Definition at line 106 of file Pane_boundary.C.

References check_face_unique(), COM_assertion_msg, Facet_ID::eid(), Facet_node_enumerator::get_nodes(), i, j, k, Facet_ID::lid(), n, Element_node_enumerator::next(), ni, nj, nk, num_elmts, num_nodes, s, Facet_node_enumerator::size_of_edges(), and Element_node_enumerator::size_of_faces().

                                                       {
  int num_nodes, num_elmts;

  if (ghost_level == 0){
    num_nodes=_pane.size_of_real_nodes();
    num_elmts=_pane.size_of_real_elements();
  } 
  else {
    COM_assertion_msg(ghost_level > 0, "Ghost level must be positive");
    num_nodes=_pane.size_of_nodes();
    num_elmts=_pane.size_of_elements();
  }

  // Initialize is_border to false for all nodes.
  is_border.clear(); is_border.resize( num_nodes, false);

  // Handle structured meshes
  if ( _pane.is_structured()) {

    const int ni=_pane.size_i(), nj=_pane.size_j(), nk=_pane.size_k();

    // s = the first index on the level above the bottom
    // t = the first index on the top level
    // h = an offset for the first index on a layer with ghosts
    // w = the length of the i dimension with ghosts
    // buffer = number of layers we 'skip' for determining borders

    int buffer = _pane.size_of_ghost_layers() - ghost_level;
    buffer = buffer < 0 ? 0 : buffer;
    int s = ni*nj;
    int t = ni*nj*(nk-1);
    int h = buffer*ni + buffer;
    int w = ni - 2*buffer;

    //bottom
    for ( int j=s*(buffer) + h, j_end = s*(1+buffer) - ni*buffer; j< j_end; j += ni){
        std::fill_n( is_border.begin() +j, w, true);
    }
    //top
    for ( int j= t+h-s*buffer, end = s*nk - s*buffer- ni*buffer; j< end; j += ni){
        std::fill_n( is_border.begin() +j, w, true);
    }
  
    //left and right 
    for ( int j= s*(1+buffer)+h, stop = t-s*buffer+h; j< stop; j += ni*nj){
        std::fill_n( is_border.begin() +j, w, true);
        std::fill_n( is_border.begin() +j + ni*((nj-1) - 2*buffer), w, true);
    }

    //upper and lower
    for ( int j= s*(1+buffer)+h; j< t-s*buffer+h; j += ni*nj){
        for (int k=ni, k_end = ni*(nj-(1+2*buffer)); k< k_end; k += ni){
            is_border[j+k] = true;
            is_border[j+k + (ni - (2*buffer+ 1)) ] = true;
        }
    }

    return;
  }

  // Now consider unstructured panes
  std::vector< Corners2Face_Map>  c2f_vec(num_nodes);
  int num_external_face=0;


  // Determine all border faces
  Element_node_enumerator ene( &_pane, 1);
  int counter = 0;
  int count2 = 0;

  for (int i=1; i<=num_elmts; ++i, ene.next()) {
  //for (int i=1; i<=6; ++i, ene.next()) {
    for (int j=0, nf=ene.size_of_faces(); j<nf; ++j ){
      Facet_node_enumerator fne( &ene, j) ;

      Four_tuple ns( fne[0], fne[1], fne[2], fne.size_of_edges()>3?fne[3]:-1);
      count2++;
      check_face_unique( ns, Facet_ID(i, j), c2f_vec, num_external_face, counter);
    }
  }

  // Mark all nodes of the border faces as border nodes, and 
  // insert their edges into b.
  if ( b) 
  { b->clear(); b->reserve( num_external_face); }

  std::vector<int> nodes; nodes.reserve(9);

  for (int i=0; i<num_nodes; ++i){
    Corners2Face_Map::const_iterator vit = c2f_vec[i].begin(); 
    Corners2Face_Map::const_iterator v_end = c2f_vec[i].end();

    for ( ; vit != v_end; ++vit) {
      // Get all nodes of the face into vector nodes.
      const Facet_ID &fid = vit->second;
      Element_node_enumerator_uns ene( &_pane, fid.eid());
      Facet_node_enumerator fne( &ene, fid.lid());
      fne.get_nodes( nodes, true);

      for ( int i=0, n=nodes.size(); i<n; ++i)
        is_border[ nodes[i] - 1 ] = true;
      
      if (b) b->push_back( fid);
    }
  }
  
}

Here is the call graph for this function:

void determine_borders ( const COM::Attribute *  mesh, COM::Attribute *  isborder, int  ghost_level = 0  )

static

Determine the nodes at pane boundaries of a given mesh.

The argument isborder must be a nodal attribute of integer type. At return, isborder is set to 1 for border nodes, and 0 for others

Definition at line 286 of file Pane_boundary.C.

References COM_assertion_msg, COM_compatible_types(), COM_INT, determine_border_nodes(), i, j, n, and nj.

Referenced by Rocmap::pane_border_nodes().

                                                        {
  COM_assertion_msg( mesh, "Unexpected NULL pointer");
  COM_assertion_msg( isborder, "Unexpected NULL pointer");
  COM_assertion_msg( COM_compatible_types( isborder->data_type(), COM_INT),
                     "Border-list must have integer type");
  COM_assertion_msg( isborder->is_nodal() == 1,
                     "Border-list must have integer type");

  std::vector<COM::Pane*> panes;
  isborder->window()->panes( panes);

  for ( int i=0, n=panes.size(); i<n; ++i) {
    Pane_boundary pb( panes[i]);
    COM::Attribute *bdl_pane = panes[i]->attribute(isborder->id());

    std::vector<bool> is_border_bitmap, is_isolated;
    pb.determine_border_nodes( is_border_bitmap, is_isolated, 
                               NULL, ghost_level);

    int *ptr = (int *)bdl_pane->pointer();
    int nj=0;
    if (ghost_level == 0)
      nj=panes[i]->size_of_real_nodes();
    else {
      COM_assertion_msg(ghost_level > 0, "Ghost level must be positive");
      nj=panes[i]->size_of_nodes();
    }
    for ( int j=0; j<nj; ++j) {
      ptr[j] = is_border_bitmap[j];
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void determine_isolated_nodes ( std::vector< bool > &  is_isolated, int  ghost_level  ) throw ( int )

protected

Determine the isolated nodes (i.e. not belonging to any element)

Definition at line 217 of file Pane_boundary.C.

References i, j, Element_node_enumerator_uns::next(), and Element_node_enumerator_uns::size_of_nodes().

                                                      {
  // Initialize to true
  is_isolated.clear();

  int nnodes = ghost_level ? 
    _pane.size_of_nodes() : _pane.size_of_real_nodes();

  if ( _pane.is_structured()) {
    // A structured mesh have no isolated nodes.
    is_isolated.resize( nnodes, false);
    return;
  }

  is_isolated.resize( nnodes, true);

  // Loop through the connectivity table to mark their nodes as false.
  Element_node_enumerator_uns ene(&_pane, 1);
  int nelems = ghost_level ?
    _pane.size_of_elements() : _pane.size_of_real_elements();
  for ( int i=0,size=nelems; i<size; ++i, ene.next()) {
    for ( int j=ene.size_of_nodes()-1; j>=0; --j)
      is_isolated[ ene[j]-1] = false;
  }
}

Here is the call graph for this function:

double min_squared_edge_len	(	const std::vector< Facet_ID > &	be	)
throw	(	int
	)

Compute the minimum squared edge length of given edges.

Definition at line 246 of file Pane_boundary.C.

References COM_NC, d, i, j, min(), Facet_node_enumerator::size_of_corners(), and square().

Referenced by Pane_connectivity::get_local_boundary_nodes().

                                                                 {
  const COM::Attribute *attr = _pane.attribute( COM::COM_NC);

  double sql = HUGE_VAL;

  // Loop through all the edges of border facets to compute the
  // shortest squared edge length.
  std::vector<Facet_ID >::const_iterator it;
  for ( it=be.begin(); it!=be.end(); ++it) {
    Element_node_enumerator ene( &_pane, it->eid());
    Facet_node_enumerator fne( &ene, it->lid());
    int ne = fne.size_of_corners();

    // Loop through all edges of the facet.
    for ( int j=0; j<fne.size_of_edges(); ++j) {
      int n1 = fne[j], n2 = fne[(j+1)%ne];
      const double *x1 = (const double*)attr->get_addr( n1-1, 0);
      const double *x2 = (const double*)attr->get_addr( n2-1, 0);

      double sqdiff;
      if ( attr->stride() >= 3) {
        // Contiguous layout of coordinates
        sqdiff = square(x1[0]-x2[0])+square(x1[1]-x2[1])+square(x1[2]-x2[2]);
      }
      else {
        // This supports R^2 points.
        sqdiff=square(x1[0]-x2[0]);
        for ( int i=1, d=attr->size_of_components(); i<d; ++i) {
          sqdiff += square((const double*)attr->get_addr( n1-1, i)-
                           (const double*)attr->get_addr( n2-1, i));
        }
      }
      
      sql = std::min( sql, sqdiff);
    }
  }

  return sql;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

const COM::Pane& _pane

private

Definition at line 87 of file Pane_boundary.h.

const Simple_manifold_2* const _pm

private

Definition at line 88 of file Pane_boundary.h.

---

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

• Pane_boundary.h
• Pane_boundary.C