Window_manifold_2 Class Reference

This class implements a data structure for 2-manifold over a whole window, which can be composed of multiple panes. More...

#include <Manifold_2.h>

Collaboration diagram for Window_manifold_2:

Public Types
typedef std::vector < Pane_manifold_2 >::iterator	PM_iterator
typedef std::vector < Pane_manifold_2 > ::const_iterator	PM_const_iterator

Public Member Functions
	Window_manifold_2 ()
	Default constructor. More...
	Window_manifold_2 (const COM::Attribute *pmesh)
	Construct a Window_manifold_2 from a given window. More...
	~Window_manifold_2 ()
int	size_of_nodes (Access_Mode mode) const
	Obtain the number of nodes (shared nodes are counted only once. More...
int	size_of_faces (Access_Mode mode) const
	Obtain the number of faces. More...
int	size_of_triangles (Access_Mode mode) const
	Obtain the number of triangles. More...
int	size_of_quadrilaterals (Access_Mode mode) const
	Obtain the number of quadrilaterals. More...
int	size_of_edges (Access_Mode mode) const
	Obtain the number of edges. More...
int	pconn_nblocks () const
	Obtain the number of pconn blocks. More...
void	serialize_window (COM::Window *outwin) const
	Create a serial window (with single pane) from the current window. More...
Buffer window management
COM::Window *	window ()
	Obtain the underlying window object. More...
const COM::Window *	window () const
Pane management
Pane_manifold_2 *	get_pane_manifold (int pid)
	Obtain a Pane_manifold_2 from a pane ID. More...
const Pane_manifold_2 *	get_pane_manifold (int pid) const
	Obtain a const Pane_manifold_2 from a pane ID. More...
int	size_of_panes () const
	Obtain the number of panes. More...
PM_iterator	pm_begin ()
	Obtain an iterator to the first pane manifold of the window. More...
PM_const_iterator	pm_begin () const
PM_iterator	pm_end ()
	Obtain an iterator to the past-the-last pane manifold of the window. More...
PM_const_iterator	pm_end () const
Communication
void	init_communicator ()
	Initialize a pane communicator. More...
void	reduce_on_shared_nodes (COM::Attribute *attr, MPI_Op op)
	Perform reduction over a given nodal attributes. More...
Utilities
void	compute_normals (COM::Attribute *normals, int scheme=E2N_ANGLE, bool to_normalize=true)
	Compute the normals at nodes or faces, depending on the type of the attribute normals. More...
void	update_bd_normals (const COM::Attribute *normals, bool to_normalize=false)
	Update the normals for border faces. More...
void	update_bd_flags (const COM::Attribute *flags)
	Update the flags for border faces. More...
void	update_bdedge_bitmap (const COM::Attribute *bitmap)
	Update bitmap for border edges. More...
void	accumulate_bd_values (const COM::Attribute *vals)
	Accumulate the values for border faces. More...
void	compute_mcn (COM::Attribute *mcn_in, COM::Attribute *lbmcn_in)
void	elements_to_nodes (const COM::Attribute *evals, COM::Attribute *nvals, const int scheme=E2N_ONE, const COM::Attribute *ews=NULL, COM::Attribute *nws=NULL, const int tosum=false)
	Convert element values to nodal values using weighted averaging. More...
void	shortest_edge_length (COM::Attribute *lens)
	Obtain shortest edge length of incident edges of each node or element. More...
void	perturb_mesh (double range)
	Perturb the given mesh along its normal direction by length equal to a random number between -range and range times shortest edge length. More...

Helper
void	init (const COM::Attribute *pmesh)
	Initialize the manifold by inheriting the given mesh. More...
void	determine_counterparts (const COM::Attribute *pconn_e)
	Determine the counterparts of pane-border edges for across-pane access. More...
void	determine_primaries (const COM::Attribute *pconn_n)
	Determine the primary nodes for across-pane access. More...
void	compute_shortest_edgelen_nodes (COM::Attribute *lens)
	Obtain shortest edge length of incident edges of each nodes. More...
void	compute_nodal_normals (COM::Attribute *nrm, int scheme=E2N_ANGLE, bool to_normalize=true, const COM::Attribute *weights=NULL)
	Compute nodal normals using one of the following weighting schemes: E2N_ONE, E2N_AREA, and E2N_ANGLE, and E2N_USER. More...
void	assign_global_nodeIDs (std::vector< std::vector< int > > &gids) const
static void	compute_shortest_edgelen_elements (COM::Attribute *lens)
	Obtain shortest edge length of incident edges of each element. More...

Data members
static MPI_Op	OP_MAX =MPI_MAX
static MPI_Op	OP_MIN =MPI_MIN
static MPI_Op	OP_SUM =MPI_SUM
static MPI_Op	OP_PROD =MPI_PROD
static MPI_Op	OP_MAXABS =MPI_MAXLOC
static MPI_Op	OP_DIFF =MPI_MINLOC
static MPI_Op	OP_BOR =MPI_BOR
static MPI_Op	OP_BAND =MPI_BAND
static MPI_Op	OP_LOR =MPI_LOR
static MPI_Op	OP_LAND =MPI_LAND
COM::Window *	_buf_window
std::vector< Pane_manifold_2 >	_pms
std::map< int, int >	_pi_map
MAP::Pane_communicator *	_cc
int	_pconn_nb

Detailed Description

This class implements a data structure for 2-manifold over a whole window, which can be composed of multiple panes.

It supports different modes in accessing the nodes and halfedges of the window.

Definition at line 185 of file Manifold_2.h.

Member Typedef Documentation

typedef std::vector< Pane_manifold_2>::const_iterator PM_const_iterator

Definition at line 188 of file Manifold_2.h.

typedef std::vector< Pane_manifold_2>::iterator PM_iterator

Definition at line 187 of file Manifold_2.h.

Constructor & Destructor Documentation

Window_manifold_2 ( )

inline

Default constructor.

Definition at line 191 of file Manifold_2.h.

: _buf_window(NULL), _cc(NULL), _pconn_nb(0) {}

Window_manifold_2 ( const COM::Attribute *  pmesh )

inlineexplicit

Construct a Window_manifold_2 from a given window.

Definition at line 194 of file Manifold_2.h.

References init().

    : _buf_window(NULL), _cc(NULL), _pconn_nb(0) { init(pmesh); }

Here is the call graph for this function:

~Window_manifold_2

(

)

Definition at line 384 of file Manifold_2.C.

References _buf_window, and _cc.

                                      { 
  if (_cc) delete _cc; _cc=NULL;
  if ( _buf_window) delete _buf_window;
}

Member Function Documentation

void accumulate_bd_values

(

const COM::Attribute *

vals

)

Accumulate the values for border faces.

Definition at line 647 of file Manifold_2.C.

References _buf_window, COM_assertion, COM_assertion_msg, COM_CHAR, COM_DOUBLE, COM_DOUBLE_PRECISION, COM_FLOAT, COM_get_sizeof(), COM_INT, COM_INTEGER, COM_REAL, copy, for(), i, iend, n, pm_begin(), and pm_end().

                                                {
  COM_assertion( vals->size_of_components()==1);
  const COM::Attribute *vals_inherited = vals;
  // Allocate buffer arrays
  if ( vals->window()!=_buf_window)
    vals_inherited = _buf_window->inherit
      ( const_cast< COM::Attribute *>(vals), "vals__CNNTEMP", false, true, NULL, 0);
  COM::Attribute *buf=_buf_window->new_attribute( "buf__PMTEMP", 'p', 
                                                  vals->data_type(), 1, "");
  COM::Attribute *pconn_g=_buf_window->new_attribute( "pconn__PMTEMP", 
                                                      'p', COM_INT, 1, "");
  COM::Attribute *pconn_e=_buf_window->attribute( "pconn_e");

  int size_base_type = COM_get_sizeof( vals->data_type(),1);

  // Fill in vals and pconn
  for ( PM_iterator it=pm_begin(), iend=pm_end(); it != iend; ++it) {
    COM::Pane *pn = const_cast<COM::Pane*>(it->pane());
    const char *vals_face = reinterpret_cast<char *>
      (pn->attribute( vals_inherited->id())->pointer());

    COM::Attribute *buf_pn = pn->attribute( buf->id());
    int n = it->size_of_real_border_edges();
    buf_pn->set_size( n, 0);

    char *val_bd;
    _buf_window->resize_array( buf->name(), pn->id(), (void**)&val_bd);

    for ( int i=0; i<n; ++i) {
      Edge_ID eid=it->get_opposite_real_edge(Edge_ID(i+1, Edge_ID::BndID));
      int fid = eid.eid();

      std::copy( &vals_face[(fid-1)*size_base_type],
                 &vals_face[fid*size_base_type], &val_bd[i*size_base_type]);
    }

    // Construct pane-connectivity
    it->convert_pconn_edge2ghost( pn->attribute( pconn_e->id()), 
                                  pn->attribute( pconn_g->id()));
  }
  _buf_window->init_done(false);

  // Perform communication
  MAP::Rocmap::update_ghosts( buf, pconn_g);

  // Reduce on the values.
  for ( PM_iterator it=pm_begin(), iend=pm_end(); it != iend; ++it) {
    COM::Pane *pn = const_cast<COM::Pane*>(it->pane());
    char *vals_face = reinterpret_cast<char *>
      (pn->attribute( vals_inherited->id())->pointer());

    int n = it->size_of_real_border_edges();

    COM::Window::Pointer_descriptor ptr(NULL);
    _buf_window->get_array( buf->name(), pn->id(), ptr);
    char *val_bd = (char*)ptr.ptr;

    for ( int i=0; i<n; ++i) {
      Edge_ID eid=it->get_opposite_real_edge(Edge_ID(i+1, Edge_ID::BndID));
      
      switch (vals->data_type()) {
      case COM_CHAR:    vals_face[eid.eid()-1] += val_bd[i]; break;
      case COM_INT:     
      case COM_INTEGER: 
        (int&)vals_face[(eid.eid()-1)*size_base_type] += 
          (int&)val_bd[i*size_base_type]; break;
      case COM_FLOAT:   
      case COM_REAL: 
        (float&)vals_face[(eid.eid()-1)*size_base_type] += 
          (float&)val_bd[i*size_base_type]; break;
      case COM_DOUBLE:
      case COM_DOUBLE_PRECISION: 
        (double&)vals_face[(eid.eid()-1)*size_base_type] += 
          (double&)val_bd[i*size_base_type]; break;
      default:
        COM_assertion_msg( false, "Unsupported type for reduction"); break;
    }
    }
  }

  _buf_window->delete_attribute( pconn_g->name());
  _buf_window->delete_attribute( buf->name());
  if ( vals_inherited != vals)
    _buf_window->delete_attribute( vals_inherited->name());
  _buf_window->init_done(false);
}

Here is the call graph for this function:

void assign_global_nodeIDs ( std::vector< std::vector< int > > &  gids ) const

protected

Definition at line 1318 of file Manifold_2.C.

References ACROSS_PANE, COM_assertion, Node::get_primary(), i, Node::id(), iend, Node::pane(), pm_begin(), pm_end(), size_of_nodes(), size_of_panes(), and v.

Referenced by serialize_window().

                                                               {
  // Initialize the vector gids
  gids.clear(); gids.resize( size_of_panes());
  std::map<int, std::vector<int>*> maps;
  PM_const_iterator it=pm_begin(), iend=pm_end();
  for ( int i=0; it!=iend; ++it, ++i) {
    gids[i].resize( it->size_of_real_nodes(), 0);
    maps[it->pane()->id()] = &gids[i];
  }

  Access_Mode mode = ACROSS_PANE;
  // Loop through the panes to assign primary nodes
  int gid = 0;
  it=pm_begin();
  for ( int i=0; it!=iend; ++it, ++i) {
    for (int v=0, nv=it->size_of_real_nodes(); v<nv; ++v) {
      if ( it->is_primary( v+1, mode))
        gids[i][v] = ++gid;
    }
  }
  COM_assertion( gid == size_of_nodes( mode));

  // Loop through the panes to assign other nodes
  it=pm_begin();
  for ( int i=0; it!=iend; ++it, ++i) {
    for (int v=0, nv=it->size_of_real_nodes(); v<nv; ++v) {
      if (gids[i][v]==0) {
        // Obtain the primary.
        Node nd = it->get_primary(v+1, mode);
        gids[i][v] = (*maps[nd.pane()->id()])[nd.id()-1];
      }
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void compute_mcn	(	COM::Attribute *	mcn_in,
		COM::Attribute *	lbmcn_in
	)

Definition at line 80 of file compute_curvature.C.

References _buf_window, COM_assertion, COM_DOUBLE, compute_lbop_weights(), Rocblas::copy_scalar(), Rocblas::div(), i, j, k, MPI_SUM, Element_node_enumerator::next(), Vector_3< Type >::norm(), reduce_on_shared_nodes(), sign(), and Element_node_enumerator::size_of_edges().

Referenced by Rocsurf::compute_mcn().

                                                           {

  COM_assertion( mcn_in != NULL && mcn_in ->size_of_components() == 3 && 
                 mcn_in->is_nodal());
  COM_assertion( lbmcn_in != NULL && lbmcn_in->size_of_components() == 3 && 
                 lbmcn_in->is_nodal());

  COM::Attribute *mcn, *lbmcn;
  // Inherit mcn and lbmcn onto buffer window
  if ( mcn_in->window() != _buf_window)
    mcn = _buf_window->inherit( mcn_in, "mcn__MCNTEMP", 
                                false, true, NULL, 0);
  else 
    mcn = mcn_in;

  if ( lbmcn_in->window() != _buf_window)
    lbmcn = _buf_window->inherit( lbmcn_in, "lbmcn__MCNTEMP", 
                                  false, true, NULL, 0);
  else
    lbmcn = lbmcn_in;

  // Allocate buffer spaces for weights and areas
  COM::Attribute *areas=NULL, *weights=NULL;
  areas = _buf_window->new_attribute( "areas__MCNTEMP", 'n',
                                      COM_DOUBLE, 1, "");
  _buf_window->resize_array( areas, NULL);

  weights = _buf_window->new_attribute( "weights__MCNTEMP", 'e',
                                        COM_DOUBLE, 12, "");
  _buf_window->resize_array( weights, NULL);
  _buf_window->init_done( false);

  // Initialize attributes to 0s
  double zero = 0.;
  Rocblas::copy_scalar( &zero, mcn);
  Rocblas::copy_scalar( &zero, areas);
  Rocblas::copy_scalar( &zero, weights);

  std::vector< COM::Pane*> panes;
  mcn->window()->panes( panes); 
  Point_3<Real> ps[4];

  std::vector< COM::Pane*>::const_iterator it = panes.begin();

  // First, compute the mean-curvature normal, and save the weights
  // for Laplace-Beltrami operator.
  for (int i=0, local_npanes = panes.size(); i<local_npanes; ++i, ++it){ 
    const COM::Pane &pane = **it;

    const Point_3<Real> *pnts =
      reinterpret_cast<const Point_3<Real>*>(pane.coordinates()); 
    Vector_3<Real> *mcn_ptr = (Vector_3<Real> *)
      (pane.attribute( mcn->id())->pointer());
    Vector_3<Real> *ws_ptr = (Vector_3<Real> *)
      (pane.attribute( weights->id())->pointer());
    Real *area_ptr = (Real *)(pane.attribute( areas->id())->pointer());

    // Loop through elements of the pane
    Element_node_enumerator ene( &pane, 1);

    for ( int j=0, jsize=pane.size_of_elements(); j<jsize; ++j, ene.next()) {
      Point_3<Real> cnt(0,0,0);
      int ne=ene.size_of_edges();
      for ( int kk=0; kk<ne; ++kk) 
        (Vector_3<Real>&)cnt += (const Vector_3<Real>&)pnts[ene[kk]-1];
      (Vector_3<Real>&)cnt /= ne;

      // Loop through each vertex 
      for ( int k=0; k<ne; ++k) {
        // Assign points for the quadrilateral.
        ps[0] = pnts[ene[k]-1];
        ps[1] = ps[0]+0.5*(pnts[ene[(k+1)%ne]-1]-ps[0]);
        ps[2] = cnt;
        ps[3] = ps[0]+0.5*(pnts[ene[(k+ne-1)%ne]-1]-ps[0]);

        // Compute weights of LB-operator for the first vertex and
        // increment the area.
        Vector_3<Real> &ws = ws_ptr[4*j+k];
        area_ptr[ ene[k]-1] += compute_lbop_weights( ps, &ws[0]);
        
        Vector_3<Real> dA = (ws[0]*(ps[1]-ps[0])+ws[1]*(ps[2]-ps[0])+
                             ws[2]*(ps[3]-ps[0]));

        mcn_ptr[ ene[k]-1] += dA;
      }
    }
  }

  // Reduce on the area and mcn and divide mcn by areas.
  reduce_on_shared_nodes( areas, MPI_SUM);
  reduce_on_shared_nodes( mcn,  MPI_SUM);
  Rocblas::div( mcn, areas, mcn);

  // Second, compute the Laplace-Beltrami of the mean-curvature.
  Rocblas::copy_scalar( &zero, lbmcn);

  it = panes.begin();
  for (int i=0, local_npanes = panes.size(); i<local_npanes; ++i, ++it) {
    const COM::Pane &pane = **it; 

    const Vector_3<Real> *mcn_ptr = (const Vector_3<Real> *)
      (pane.attribute( mcn->id())->pointer());
    const Vector_3<Real> *ws_ptr = (const Vector_3<Real> *)
      (pane.attribute( weights->id())->pointer());

    Vector_3<Real> *lbmcn_ptr = (Vector_3<Real> *)
      (pane.attribute( lbmcn->id())->pointer());

    // Loop through elements of the pane
    Element_node_enumerator ene( &pane, 1); 
    double fs[4];

    for ( int j=0, jsize=pane.size_of_elements(); j<jsize; ++j, ene.next()) {
      int ne=ene.size_of_edges();

      // Loop through each vertex 
      for ( int k=0; k<ne; ++k) {

        // Compute the magnitude and vector of current vertex
        int ii0=ene[k]-1;
        fs[0] = mcn_ptr[ii0].norm();
        Vector_3<Real> vec=(mcn_ptr[ii0]);  if (fs[0]>0) vec/=fs[0];
        
        // Compute length of other vertices mcn corresponding to the 
        // direction of mcn at the current vertex
        for ( int kk=1; kk<ne; ++kk) {
          int ii=ene[(k+kk)%ne]-1;

          fs[kk] = sign(mcn_ptr[ii]*vec)*mcn_ptr[ii].norm();
        }

        const Vector_3<Real> &ws = ws_ptr[4*j+k];
        lbmcn_ptr[ ene[k]-1] += 4.*(ws[0]*(fs[1]-fs[0])+ws[1]*(fs[2]-fs[0])+
                                    ws[2]*(fs[3]-fs[0]))*vec;
      }
    }
  }

  // Reduce on lbmcn and divide it by areas.
  reduce_on_shared_nodes( lbmcn,  MPI_SUM);
  Rocblas::div( lbmcn, areas, lbmcn);

  // Delete buffer space in reverse order
  _buf_window->delete_attribute( weights->name());
  _buf_window->delete_attribute( areas->name());
  if ( lbmcn_in->window() != _buf_window)
    _buf_window->delete_attribute( lbmcn->name());
  if ( mcn_in->window() != _buf_window)
    _buf_window->delete_attribute( mcn->name());

  _buf_window->init_done(false);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void compute_nodal_normals ( COM::Attribute *  nrm, int  scheme = E2N_ANGLE, bool  to_normalize = true, const COM::Attribute *  weights = NULL  )

protected

Compute nodal normals using one of the following weighting schemes: E2N_ONE, E2N_AREA, and E2N_ANGLE, and E2N_USER.

compute_normals()

Definition at line 764 of file Manifold_2.C.

References _buf_window, _cc, COM_assertion_msg, COM_DOUBLE, Rocsurf::compute_element_normals(), E2N_AREA, E2N_ONE, elements_to_nodes(), i, init_communicator(), j, and n.

Referenced by compute_normals(), and perturb_mesh().

                                                    {
  COM_assertion_msg( weights==NULL || weights->is_elemental(),
                     "Weights for elemental normals must be elemental");
  if ( _cc==NULL) init_communicator();

  // Inherit normals onto the window
  COM::Attribute *nodal_normals;
  if ( nrms->window() != _buf_window)
    nodal_normals = _buf_window->inherit( nrms, "nodal_normals__CNNTEMP", 
                                          false, true, NULL, 0);
  else 
    nodal_normals = nrms;

  COM::Attribute *elem_normals = _buf_window->
    new_attribute( "elem_normals__CNNTEMP", 'e', COM_DOUBLE, 3, "");
  _buf_window->resize_array( elem_normals, NULL);
  _buf_window->init_done();

  if ( scheme == E2N_AREA) {
    int normalize=false;
    Rocsurf::compute_element_normals( elem_normals, &normalize);
    elements_to_nodes( elem_normals, nodal_normals, E2N_ONE, NULL, NULL, true);
  }
  else {
    Rocsurf::compute_element_normals( elem_normals);
    elements_to_nodes( elem_normals, nodal_normals, scheme, weights);
  }

  // Normalize the vectors
  if ( to_normalize) {
    std::vector<COM::Pane*>::iterator it=_cc->panes().begin();
    for (int i=0, n=_cc->panes().size(); i<n; ++i, ++it) {
      int nnodes = (*it)->size_of_real_nodes();
      Vector_3<double>* ptrs = 
        (Vector_3<double>*)(*it)->attribute(nodal_normals->id())->pointer();
      for ( int j=0; j<nnodes; ++j)
        ptrs[j].normalize();
    }
  }

  // Deallocate buffer in reverse order
  _buf_window->delete_attribute( elem_normals->name());
  if ( nrms->window() != _buf_window)
    _buf_window->delete_attribute( nodal_normals->name());
  _buf_window->init_done( false);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void compute_normals	(	COM::Attribute *	normals,
		int	scheme = E2N_ANGLE,
		bool	to_normalize = true
	)

Compute the normals at nodes or faces, depending on the type of the attribute normals.

For nodal normals, use one of the following weighting schemes: E2N_ONE: Same weight for all incident faces. E2N_AREA: Area of incident faces. E2N_ANGLE: Angle of the incident faces at the node.

Definition at line 1045 of file Manifold_2.C.

References COM_assertion_msg, COM_compatible_types(), COM_DOUBLE, Rocsurf::compute_element_normals(), and compute_nodal_normals().

Referenced by Rocsurf::compute_normals().

                                                            {
  COM_assertion_msg( normal, "Encountered NULL pointer/");
  COM_assertion_msg( normal->size_of_components()==3,
                     "Normal must have three components");
  COM_assertion_msg( COM_compatible_types(normal->data_type(), COM_DOUBLE),
                     "Base type of Normal must be double precision"); 

  if ( normal->is_nodal()) {
    compute_nodal_normals( normal, scheme, to_normalize);
  }
  else {
    COM_assertion_msg( normal->is_elemental(), 
                       "Normal must be nodal or elemental");
    int to_nrm = to_normalize;
    Rocsurf::compute_element_normals( normal, &to_nrm);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void compute_shortest_edgelen_elements ( COM::Attribute *  lens )

staticprotected

Obtain shortest edge length of incident edges of each element.

Definition at line 457 of file Manifold_2.C.

References i, j, k, min(), Element_node_enumerator::next(), Element_node_enumerator::size_of_edges(), and sqrt().

Referenced by shortest_edge_length().

                                                       {
  std::vector< COM:: Pane*> panes;
  lens->window()-> panes( panes); 
  std::vector< COM::Pane*>::const_iterator it = panes.begin();
  
  for (int i=0, local_npanes = panes.size(); i<local_npanes; ++i, ++it){ 
    const COM::Pane &pane = **it; 
    const Point_3<Real> *pnts = 
      reinterpret_cast<const Point_3<Real>*>(pane.coordinates()); 
    Real *lp = (Real *)(pane.attribute( lens->id())->pointer());
    
    // Loop through elements of the pane
    Element_node_enumerator ene( &pane, 1); 
    for ( int j=pane.size_of_elements(); j>0; --j, ene.next(),++lp) {
      Real sqlen = HUGE_VAL;

      int uindex = ene[0]-1;
      for (int k = 0, ne=ene.size_of_edges(); k<ne; k++){
        int vindex=ene[(k+1)%ne]-1;
        sqlen = std::min( sqlen, (pnts[ uindex]-pnts[ vindex]).squared_norm());
        uindex = vindex;
      }
      *lp = std::sqrt(sqlen);
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void compute_shortest_edgelen_nodes ( COM::Attribute *  lens )

protected

Obtain shortest edge length of incident edges of each nodes.

Obtain shortest edge length of incident edges of each element.

Definition at line 415 of file Manifold_2.C.

References Rocblas::copy_scalar(), i, j, k, min(), Element_node_enumerator::next(), OP_MIN, reduce_on_shared_nodes(), Element_node_enumerator::size_of_edges(), Element_node_enumerator::size_of_nodes(), and Rocblas::sqrt().

Referenced by perturb_mesh(), and shortest_edge_length().

                                                    {
  std::vector< COM:: Pane*> panes;
  lens->window()-> panes( panes); 
  std::vector< COM::Pane*>::const_iterator it = panes.begin();

  // Initialize to HUGE_VAL
  double inf=HUGE_VAL;
  Rocblas::copy_scalar( &inf, lens);

  for (int i=0, local_npanes = panes.size(); i<local_npanes; ++i, ++it){ 
    const COM::Pane &pane = **it; 
    const Point_3<Real> *pnts = 
      reinterpret_cast<const Point_3<Real>*>(pane.coordinates()); 
    Real *lp = (Real *)(pane.attribute( lens->id())->pointer());
    
    // Loop through elements of the pane
    Element_node_enumerator ene( &pane, 1);
    for ( int j=pane.size_of_elements(); j>0; --j, ene.next()) {
      int nn=ene.size_of_nodes();
      int uindex = ene[0]-1;
      for (int k = 0, ne=ene.size_of_edges(); k<ne; k++){
        int vindex=ene[(k+1)%ne]-1;
        double sqlen = (pnts[ uindex]-pnts[ vindex]).squared_norm();

        lp[uindex] = std::min( lp[uindex], sqlen);
        lp[vindex] = std::min( lp[vindex], sqlen);
        if ( nn>ne) lp[uindex+ne] = std::min( lp[uindex+ne], sqlen);
        if ( nn>ne+ne) lp[uindex+ne+ne] = std::min( lp[uindex+ne+ne], sqlen);

        uindex = vindex;
      }
    }
  }

  // Reduce on shared nodes and then compute squared roots.
  reduce_on_shared_nodes( lens, OP_MIN);
  Rocblas::sqrt( lens, lens);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void determine_counterparts ( const COM::Attribute *  pconn_e )

protected

Determine the counterparts of pane-border edges for across-pane access.

Definition at line 241 of file Manifold_2.C.

References Pane_manifold_2::_bd_cnt, Pane_manifold_2::_cnt_pn, _pi_map, _pms, ACROSS_PANE, COM_assertion_msg, Simple_manifold_2::get_border_edgeID(), Simple_manifold_2::get_opposite_real_edge(), i, j, k, n, nj, nk, p1, and Simple_manifold_2::pane().

Referenced by init().

                                                                          {

  const int pconn_offset=MAP::Pane_connectivity::pconn_offset();

  typedef std::map< std::pair<int,int>,
    std::pair< const int*, const int*> >  B2e_map;
  B2e_map bm;

  // First, loop through the pane-connectivity arrays in all local panes
  // to construct a mapping from the internal local pane ids (between 0 and
  // #local_panes-1) of each pair of abutting local panes to the addresses
  // in the pane-connectivity arrays corresponding to the communication
  // patterns of the two panes. This mapping is stored in B2e_map, and 
  // will allow convenient construction of the counterparts in the second step.
  // Note: As a side-product, this step also fills in _cnt_pn for the edges.
  for ( int i=0, n=_pms.size(); i<n; ++i) {
    Pane_manifold_2     &pm = _pms[i];
    const COM::Attribute *pconn_l = pm.pane()->attribute(pconn_e->id());
    const int *b2e_l = (const int*)pconn_l->pointer();

    int pane_id_l = i;

    for ( int j=pconn_offset, nj=pconn_l->size_of_real_items(); 
          j<nj; j+=b2e_l[j+1]+2) {

      std::map<int,int>::iterator it= _pi_map.find( b2e_l[j]);
      bool is_remote = it == _pi_map.end();

      // Loop through the edges in the pconn to assign _cnt_pn.
      int pnid_other = b2e_l[j]; 
      if ( is_remote) pnid_other = -pnid_other;

      const Edge_ID *es = (const Edge_ID*)(&b2e_l[j+2]);
      for ( int k=0, nk=b2e_l[j+1]; k<nk; ++k) { 
        pm._cnt_pn[pm.get_border_edgeID(pm.get_opposite_real_edge(es[k]))-1]
          = pnid_other;
        // Note: this handles branch-cut as well.
      }

      if ( is_remote) continue; // skip remote panes

      // Insert addresses of the pconn arrayes into B2e_map
      int pane_id_r = it->second;

      if ( pane_id_l <= pane_id_r)
        bm[ std::make_pair( pane_id_l, pane_id_r)].first = &b2e_l[j+1];
      if ( pane_id_l >= pane_id_r)
        bm[ std::make_pair( pane_id_r, pane_id_l)].second = &b2e_l[j+1];
    }
  }
  
  // Second, loop through the B2e_map to insert *local* counterparts of 
  // border-edges into _bd_cnt (i.e., if the counterpart of an edge is
  // on a remote process, the counterpart is ignored).
  for ( B2e_map::const_iterator it=bm.begin(); it!=bm.end(); ++it) {
    Pane_manifold_2     *p1 = &_pms[it->first.first];
    Pane_manifold_2     *p2 = &_pms[it->first.second];
    const int *v1 = it->second.first;
    const int *v2 = it->second.second;

    int is_branchcut = (it->first.first == it->first.second);
    COM_assertion_msg( ! is_branchcut || *v1%2==0, 
                       "Branch-cut must list nodes in pairs.");
    
    for ( int k=1, nk=*v1; k<=nk; ++k) {
      const Edge_ID e1 = (Edge_ID&)v1[k];
      const Edge_ID e2 = (Edge_ID&)v2[k+is_branchcut];
      
      p1->_bd_cnt[p1->get_border_edgeID(p1->get_opposite_real_edge(e1))-1] =
        Halfedge(p2, e2, ACROSS_PANE);
      
      p2->_bd_cnt[p2->get_border_edgeID(p2->get_opposite_real_edge(e2))-1] =
        Halfedge(p1, e1, ACROSS_PANE);

      if (is_branchcut) ++k;
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void determine_primaries ( const COM::Attribute *  pconn_n )

protected

Determine the primary nodes for across-pane access.

Definition at line 320 of file Manifold_2.C.

References Pane_manifold_2::_nd_prm, _pi_map, _pms, ACROSS_PANE, COM_assertion_msg, Pane_manifold_2::get_bnode_index(), Node::halfedge(), i, Halfedge::is_border(), Node::is_isolated(), j, k, n, nj, nk, and p1.

Referenced by init().

                                                                        {
  // Using the pane connectivity to construct a helper map bm, which 
  // maps from the pane IDs of each pair of incident panes to its 
  // correponding arrays in b2v.
  // Note in each pane-ID pair, the first ID is no greater than the second.
  typedef std::map< std::pair<int,int>, 
    std::pair< const int*, const int*> >  B2v_map;
  B2v_map bm;

  const int pconn_offset=MAP::Pane_connectivity::pconn_offset();

  for ( int i=0, n=_pms.size(); i<n; ++i) {
    const COM::Attribute *pconn_l = _pms[i].pane()->attribute(pconn_n->id());
    const int *b2v_l = (const int*)pconn_l->pointer();
    int pane_id_l = i;
    
    for ( int j=pconn_offset, nj=pconn_l->size_of_real_items(); 
          j<nj; j+=b2v_l[j+1]+2) {

      std::map<int,int>::iterator it= _pi_map.find( b2v_l[j]);
      if ( it == _pi_map.end()) continue; // skip remote panes

      int pane_id_r = it->second;

      if ( pane_id_l <= pane_id_r)
        bm[ std::make_pair( pane_id_l, pane_id_r)].first = &b2v_l[j+1];
      if ( pane_id_l >= pane_id_r)
        bm[ std::make_pair( pane_id_r, pane_id_l)].second = &b2v_l[j+1];
    }
  }
  
  // Now loop through bm to compute _nd_prm within the process.
  for ( B2v_map::const_iterator it=bm.begin(); it!=bm.end(); ++it) {
    Pane_manifold_2     *p1 = &_pms[it->first.first];
    Pane_manifold_2     *p2 = &_pms[it->first.second];
    const int *v1 = it->second.first, *v2=it->second.second;

    int is_branchcut = (it->first.first == it->first.second);
    COM_assertion_msg( ! is_branchcut || *v1%2==0, 
                       "Branch-cut must list nodes in pairs.");

    for ( int k=1, nk=*v1; k<=nk; ++k) {
      Node node1( p1, v1[k], ACROSS_PANE);
      Node node2( p2, v2[k+is_branchcut], ACROSS_PANE);

      int i1 = p1->get_bnode_index( v1[k]);
      if ( i1>=0 && !node2.is_isolated() &&
           ( node2.halfedge().is_border() || 
             node1.is_isolated() && p1->_nd_prm[i1].pane()==0 )) {
        p1->_nd_prm[i1] = node2;
      }
      else {
        int i2 = p2->get_bnode_index( v2[k+is_branchcut]);
        if ( i2 >= 0 && !node1.is_isolated() &&
             (node1.halfedge().is_border() || p2->_nd_prm[i2].pane()==0)) {
          p2->_nd_prm[i2] = node1;
        }
      }

      if (is_branchcut) ++k;
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void elements_to_nodes	(	const COM::Attribute *	evals,
		COM::Attribute *	nvals,
		const int	scheme = E2N_ONE,
		const COM::Attribute *	ews = NULL,
		COM::Attribute *	nws = NULL,
		const int	tosum = false
	)

Convert element values to nodal values using weighted averaging.

The weighting scheme can be user-defined (E2N_USER, given by ews), one for each element (E2N_ONE, default), area of the element (E2N_AREA), or angle at each node (E2N_ANGLE). If nws is present, then output weights into nws. If tosum is true, then compute weighted sum instead of weighted average.

Definition at line 816 of file Manifold_2.C.

References _buf_window, _cc, cimg_library::acos(), COM_assertion_msg, COM_compatible_types(), COM_DOUBLE, Vector_3< Type >::cross_product(), d, E2N_ANGLE, E2N_AREA, E2N_ONE, E2N_SPHERE, E2N_USER, i, init_communicator(), j, Generic_element_2::Jacobian(), k, MPI_SUM, n, Element_node_enumerator::next(), OP_SUM, reduce_on_shared_nodes(), s, Element_node_vectors_k_const< Value >::set(), Element_node_vectors_k< Value >::set(), Element_vectors_k_const< Value >::set(), sin, Element_node_enumerator::size_of_edges(), Element_node_enumerator::size_of_nodes(), sqrt(), Vector_3< Type >::squared_norm(), and v.

Referenced by compute_nodal_normals(), and Rocsurf::elements_to_nodes().

                                    {
  COM_assertion_msg( e_vals && e_vals->is_elemental(),
                     "First argument must be elemental attribute");
  COM_assertion_msg( n_vals && n_vals->is_nodal(),
                     "Second argument must be nodal attribute");
  COM_assertion_msg( scheme!=E2N_USER || 
                     e_weights && e_weights->is_elemental(),
                     "Third argument must be elemental attribute");
  COM_assertion_msg( !n_weights || n_weights->is_nodal() && 
                     COM_compatible_types(COM_DOUBLE, n_weights->data_type()),
                     "Output weights must be nodal with double precision");

  // Inherit nodal and elemental values onto the window
  COM::Attribute *nodal_vals;
  if ( n_vals->window() != _buf_window)
    nodal_vals = _buf_window->inherit( n_vals, "nodal_vals__E2NTEMP", 
                                       false, true, NULL, 0);
  else 
    nodal_vals = n_vals;

  const COM::Attribute *elem_vals;
  if ( e_vals->window() != _buf_window)
    elem_vals = _buf_window->inherit
      ( const_cast<COM::Attribute*>(e_vals), "elem_vals__E2NTEMP", 
        false, true, NULL, 0);
  else
    elem_vals = e_vals;

  // Inherit nodal and elemental weights onto the window
  COM::Attribute *nodal_weights; 
  if ( n_weights && n_weights->window()!=_buf_window) 
    nodal_weights = _buf_window->inherit( n_weights, "nodal_weights__E2NTEMP", 
                                          false, true, NULL, 0);
  else {
    nodal_weights = _buf_window->new_attribute( "nodal_weights__E2NTEMP", 'n',
                                                COM_DOUBLE, 1, "");
    _buf_window->resize_array( nodal_weights, NULL);
  }

  const COM::Attribute *elem_weights; 
  if ( e_weights && e_weights->window()!=_buf_window) 
    elem_weights = _buf_window->inherit
      ( const_cast<COM::Attribute*>(e_weights), "elem_weights__E2NTEMP", 
        false, true, NULL, 0);
  else
    elem_weights = e_weights;
  _buf_window->init_done( false);

  // Initialize communicator
  if ( _cc==NULL) init_communicator();
  int local_npanes = _cc->panes().size();

  // Initialize buffer spaces for nodal weights.
  std::vector< Real*> weights_ptrs(local_npanes);
  std::vector< int>   weights_strds(local_npanes);
  
  int ncomp = nodal_vals->size_of_components();
  COM_assertion_msg( elem_vals->size_of_components()==ncomp,
                     "Numbers of components must match");

  for (int i=0; i<local_npanes; ++i) {
    int nn=_cc->panes()[i]->size_of_real_nodes();
    Real *p;
    int  strd;
    COM::Attribute *a = _cc->panes()[i]->attribute(nodal_weights->id());
    p = weights_ptrs[i] = reinterpret_cast<Real*>(a->pointer());
    strd = weights_strds[i] = a->stride();

    // Initialize values to 0.
    for ( int k=0; k<nn; ++k, p+=strd) *p = 0.;
  }

  Vector_3<Real> J[2];
  Vector_2<Real> nc(0.5,0.5);

  Element_node_vectors_k_const<Point_3<Real> > ps;
  Element_vectors_k_const<Real>                elem_vals_evk;
  Element_node_vectors_k<Real>                 nodal_vals_evk;
  Element_vectors_k_const<Real>                elem_weights_evk;
  Element_node_vectors_k<Real>                 nodal_weights_evk;

  // Compute nodal sums and weights on each processor
  std::vector< COM::Pane*>::const_iterator it=_cc->panes().begin();
  for (int i=0; i<local_npanes; ++i, ++it) { // Loop through the panes
    COM::Pane &pane = **it;

    const Point_3<Real> *pnts = reinterpret_cast<const Point_3<Real>*>
      (pane.coordinates());
    const COM::Attribute *elem_vals_pane = 
      pane.attribute( elem_vals->id());
    const COM::Attribute *elem_weights_pane = 
      elem_weights ? pane.attribute( elem_weights->id()) : NULL;
    COM::Attribute *nodal_vals_pane = 
      pane.attribute( nodal_vals->id());

    // Initialize values of nodal_vals_pane to 0.
    for ( int d=1; d<=ncomp; ++d) {
      COM::Attribute *nvpi = ncomp==1?nodal_vals_pane:(nodal_vals_pane+d);
      Real *p=reinterpret_cast<Real*>(nvpi->pointer());
      for ( int j=0,s=nvpi->stride(),n=nvpi->size_of_real_items()*s; j<n; j+=s)
        p[j] = 0.;
    }

    // Loop through the elements of the pane
    Element_node_enumerator ene( &pane, 1); 
    for ( int j=pane.size_of_real_elements(); j>0; --j, ene.next()) {
      ps.set( pnts, ene, 1);
      elem_vals_evk.set( elem_vals_pane, ene);
      nodal_vals_evk.set( nodal_vals_pane, ene);
      nodal_weights_evk.set( weights_ptrs[i], ene, weights_strds[i]);

      int ne=ene.size_of_edges();
      int nn=ene.size_of_nodes();
      Real w = 1.;
      switch ( scheme) {
      case E2N_USER:
      case E2N_AREA:
        if ( scheme == E2N_USER) {
          // Use user specified weights.
          elem_weights_evk.set( elem_weights_pane, ene);
          w = elem_weights_evk[0];
        } // Continue to the case of E2N_ONE
        else { 
          Generic_element_2 e(ne, nn);
          e.Jacobian( ps, nc, J);
          
          const Vector_3<Real> v = Vector_3<Real>::cross_product( J[0], J[1]);
          w = std::sqrt(v.squared_norm());
          if ( ne==3) w*=0.5;
        }  // Continue to the case of E2N_ONE
      case E2N_ONE: {
        // Update nodal weights
        for ( int k=0; k<nn; ++k)
          nodal_weights_evk[k] += w;
        
        // Update nodal sums
        for ( int d=0; d<ncomp; ++d) {
          Real t = w*elem_vals_evk(0,d);
          for ( int k=0; k<nn; ++k)
            nodal_vals_evk(k,d) += t;
        }
        break;
      }
      case E2N_ANGLE:
      case E2N_SPHERE: {
        for ( int k=0; k<ne; ++k) { 
          J[0] = ps[k==ne-1?0:k+1]-ps[k]; J[1] = ps[k?k-1:ne-1]-ps[k]; 
          double s = std::sqrt((J[0]*J[0])*(J[1]*J[1]));
          if ( s>0) {
            double cosw = J[0]*J[1]/s; 
            if (cosw>1) cosw=1; else if ( cosw<-1) cosw=-1;
            w = std::acos( cosw);

            if ( scheme==SURF::E2N_SPHERE)
              w = std::sin(w)/s; 

            // Update nodal weights
            nodal_weights_evk[k] += w;
            
            // Update nodal sums
            for ( int d=0; d<ncomp; ++d)
              nodal_vals_evk(k,d) += w*elem_vals_evk(0,d);
          }
        }
        for ( int k=ne; k<nn; ++k) {
          // Update nodal weights
          nodal_weights_evk[k] += 1;

          // Update nodal sums
          for ( int d=0; d<ncomp; ++d)
            nodal_vals_evk(k,d) += elem_vals_evk(0,d);
        }
        break;
      }

      default: COM_assertion_msg(false, "Should never reach here");
      }
    }
  }

  // Performan reductions on shared nodes for nodal sums
  reduce_on_shared_nodes( nodal_vals, OP_SUM);

  // Performan reductions on shared nodes for nodal weights
  _cc->init( &(void*&)weights_ptrs[0], COM_DOUBLE, 1, NULL, NULL);
  _cc->begin_update_shared_nodes();
  _cc->reduce_on_shared_nodes( MPI_SUM);
  _cc->end_update_shared_nodes();

  if ( !tosum) {
    // Divide nodal sums by weights on each processor
    it=_cc->panes().begin();
    for (int i=0; i<local_npanes; ++i, ++it) { // Loop through the panes
      COM::Pane &pane = **it;
      COM::Attribute *nodal_vals_pane = pane.attribute( nodal_vals->id());

      for ( int d=1; d<=ncomp; ++d) {
        COM::Attribute *nvpi = ncomp==1?nodal_vals_pane:(nodal_vals_pane+d);
        Real *v=reinterpret_cast<Real*>(nvpi->pointer());
        Real *w = weights_ptrs[i];
        for ( int j=0,js=nvpi->stride(),n=nvpi->size_of_real_items()*js,
                k=0, ks=weights_strds[i]; j<n; j+=js, k+=ks) {
          if ( w[k]==0) {
            std::cout << "***Rocsurf Error: Got zero weight for node " 
                      << j+1 << " in pane " << pane.id() << std::endl;
          }
          if ( w[k] == 0) v[j] = 0;
          else v[j] /= w[k];
        }
      }
    }
  }

  // Delete the temporary attributs in reverse order.
  if ( elem_weights != e_weights) 
    _buf_window->delete_attribute( elem_weights->name());
  _buf_window->delete_attribute( nodal_weights->name());
  if ( elem_vals != e_vals) 
    _buf_window->delete_attribute( elem_vals->name());
  if (nodal_vals != n_vals) 
    _buf_window->delete_attribute( nodal_vals->name());
  _buf_window->init_done( false);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Pane_manifold_2* get_pane_manifold ( int  pid )

inline

Obtain a Pane_manifold_2 from a pane ID.

Definition at line 212 of file Manifold_2.h.

  { return &_pms[ _pi_map[pid]]; }

const Pane_manifold_2* get_pane_manifold ( int  pid ) const

inline

Obtain a const Pane_manifold_2 from a pane ID.

Definition at line 216 of file Manifold_2.h.

References _pi_map, and _pms.

  { return &_pms[ _pi_map.find(pid)->second]; }

void init ( const COM::Attribute *  pmesh )

protected

Initialize the manifold by inheriting the given mesh.

Called by constructors of Window_manifold_2.

Definition at line 171 of file Manifold_2.C.

References _buf_window, _pconn_nb, _pi_map, _pms, ACROSS_PANE, COM_assertion_msg, COM_INT, COM_MESH, COM_PCONN, COM_PMESH, determine_counterparts(), determine_primaries(), and i.

Referenced by Window_manifold_2().

                                                       {
  COM_assertion_msg( pmesh && pmesh->id()==COM::COM_MESH ||
                     pmesh->id()==COM::COM_PMESH, 
                     "Input to Window_manifold_2::init must be mesh or pmesh");
  if ( _buf_window) delete _buf_window;

  const COM::Window *w = pmesh->window();

  // Create a buffer window by inheriting from the given mesh.
  _buf_window = new COM::Window(w->name()+"-buf", w->get_communicator());
  _buf_window->inherit( const_cast<COM::Attribute*>(pmesh), "", 
                        false, true, NULL, 0);

  // If pconn is not given, allocate pconn by cloning the pconn from user space
  COM::Attribute *pconn_user = 
    const_cast<COM::Attribute*>(w->attribute(COM::COM_PCONN));
  bool nopconn = ( pmesh->id() == COM::COM_MESH ||
                   MAP::Pane_connectivity::pconn_nblocks( pconn_user)==0);

  // Determine whether to compute pconn by itself.
  COM::Attribute *pconn_n = nopconn ? 
    _buf_window->inherit( pconn_user, "", true, true, NULL, 0) :
    _buf_window->attribute( COM::COM_PCONN);

  // Create an attribute for edge connectivity across panes
  COM::Attribute *pconn_e = 
    _buf_window->new_attribute( "pconn_e", 'p', COM_INT, 1, "");

  _buf_window->init_done();

  std::vector<const COM::Pane*> panes;
  _buf_window->panes(panes);

  std::vector<const MAP::Simple_manifold_2*> mani2(panes.size());

  // Initialize pane-manifolds.  
  _pms.resize( panes.size());
  for ( int i=panes.size()-1; i>=0; --i) {
    _pi_map[ panes[i]->id()] = i;  // Internal local pane-ID

    _pms[i].init( panes[i]);
    mani2[i] = &_pms[i];

    // _bd_cnt and _phy_bnd will be updated by determine_counterparts
    int nb = _pms[i].size_of_real_border_edges();
    _pms[i]._cnt_pn.resize( nb, 0);  
    _pms[i]._bd_cnt.resize( nb, Halfedge(NULL, Edge_ID(),ACROSS_PANE));

    // _nd_prm to be updated by determine_primaries
    _pms[i]._nd_prm.resize( nb+_pms[i].size_of_isolated_nodes(), 
                            Node(NULL,0,ACROSS_PANE));
  }

  // Compute node and edge correspondence if not given
  if ( !mani2.empty()) {
    MAP::Pane_connectivity pc( &mani2[0], w->get_communicator());
    pc.compute_pconn( nopconn?pconn_n:(COM::Attribute*)NULL, pconn_e);

    determine_counterparts( pconn_e); // Update _cnt_pn and _bd_cnt
    determine_primaries( pconn_n);    // Update _nd_prm
  }
  else {
    MAP::Pane_connectivity pc( pmesh, w->get_communicator());
    pc.compute_pconn( nopconn?pconn_n:(COM::Attribute*)NULL, pconn_e);
  }

  // Obtain the number of pconn blocks
  _pconn_nb = MAP::Pane_connectivity::pconn_nblocks( pconn_n);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void init_communicator

(

)

Initialize a pane communicator.

Must be called before any operation involving interprocess communication.

Definition at line 389 of file Manifold_2.C.

References _buf_window, and _cc.

Referenced by compute_nodal_normals(), elements_to_nodes(), and Rocsurf::initialize().

                                          {
  if ( _cc) { delete _cc; }
  
  _cc = new MAP::Pane_communicator( _buf_window, 
                                    _buf_window->get_communicator());
}

Here is the caller graph for this function:

int pconn_nblocks ( ) const

inline

Obtain the number of pconn blocks.

Definition at line 312 of file Manifold_2.h.

References _pconn_nb.

{ return _pconn_nb; }

void perturb_mesh

(

double

range

)

Perturb the given mesh along its normal direction by length equal to a random number between -range and range times shortest edge length.

Definition at line 1065 of file Manifold_2.C.

References _buf_window, Rocblas::add(), COM_DOUBLE, COM_NC, compute_nodal_normals(), compute_shortest_edgelen_nodes(), Rocblas::mul(), OP_MAXABS, Rocblas::rand_scalar(), reduce_on_shared_nodes(), and Rocblas::sub_scalar().

                                                  {
  // Allocate buffer arrays
  COM::Attribute *nrm=_buf_window->new_attribute( "normals__PMTEMP", 
                                                  'n', COM_DOUBLE, 3, "");
  _buf_window->resize_array( nrm, NULL);
  
  COM::Attribute *rnd=_buf_window->new_attribute( "randoms__PMTEMP", 
                                                  'n', COM_DOUBLE, 1, "");
  _buf_window->resize_array( rnd, NULL);

  COM::Attribute *lens=_buf_window->new_attribute( "lengths__PMTEMP", 
                                                   'n', COM_DOUBLE, 1, "");
  _buf_window->resize_array( lens, NULL);

  _buf_window->init_done( false);

  // Obtain random numbers between -range and +range
  double dbl_range=range*2;
  Rocblas::rand_scalar( &dbl_range, rnd);
  Rocblas::sub_scalar( rnd, &range, rnd);
  reduce_on_shared_nodes( rnd, OP_MAXABS);

  // Compute normal direction and multiply it with random numbers
  compute_nodal_normals( nrm);
  compute_shortest_edgelen_nodes( lens);
  Rocblas::mul( rnd, lens, rnd);
  Rocblas::mul( nrm, rnd, nrm);

  // Add normal components to coordinates
  COM::Attribute *nc = _buf_window->attribute(COM::COM_NC);
  Rocblas::add( nc, nrm, nc);

  // Deallocate buffers
  _buf_window->delete_attribute( lens->name());
  _buf_window->delete_attribute( rnd->name());
  _buf_window->delete_attribute( nrm->name());
  _buf_window->init_done( false);
}

Here is the call graph for this function:

PM_iterator pm_begin ( )

inline

Obtain an iterator to the first pane manifold of the window.

Definition at line 223 of file Manifold_2.h.

References _pms.

Referenced by accumulate_bd_values(), assign_global_nodeIDs(), Rocsurf::compute_edge_lengths(), serialize_window(), size_of_edges(), size_of_faces(), size_of_nodes(), size_of_quadrilaterals(), size_of_triangles(), update_bd_flags(), update_bd_normals(), and update_bdedge_bitmap().

{ return _pms.begin(); }

Here is the caller graph for this function:

PM_const_iterator pm_begin ( ) const

inline

Definition at line 224 of file Manifold_2.h.

References _pms.

{ return _pms.begin(); }

PM_iterator pm_end ( )

inline

Obtain an iterator to the past-the-last pane manifold of the window.

Definition at line 227 of file Manifold_2.h.

References _pms.

Referenced by accumulate_bd_values(), assign_global_nodeIDs(), Rocsurf::compute_edge_lengths(), serialize_window(), size_of_edges(), size_of_faces(), size_of_nodes(), size_of_quadrilaterals(), size_of_triangles(), update_bd_flags(), update_bd_normals(), and update_bdedge_bitmap().

{ return _pms.end(); }

Here is the caller graph for this function:

PM_const_iterator pm_end ( ) const

inline

Definition at line 228 of file Manifold_2.h.

References _pms.

{ return _pms.end(); }

void reduce_on_shared_nodes	(	COM::Attribute *	attr,
		MPI_Op	op
	)

Perform reduction over a given nodal attributes.

Definition at line 1105 of file Manifold_2.C.

References _buf_window, _cc, COM_assertion, OP_DIFF, and OP_MAXABS.

Referenced by compute_mcn(), compute_shortest_edgelen_nodes(), elements_to_nodes(), and perturb_mesh().

                                                       {
  COM_assertion( attr->is_nodal());

  COM::Attribute *attr_inherited = attr;
  if ( attr->window() != _buf_window) {
    // If attribute is not on buffer-window, inherit it.
    attr_inherited = _buf_window->inherit(attr, "SuRf_ReDuCe_On_ShArEd_TeMp__",
                                          COM::Pane::INHERIT_USE, true, NULL, 0);
    _buf_window->init_done( false);
  }
  _cc->init( attr_inherited);
  _cc->begin_update_shared_nodes();
  if ( op == OP_MAXABS) 
    _cc->reduce_maxabs_on_shared_nodes();
  else if ( op == OP_DIFF)
    _cc->reduce_diff_on_shared_nodes();
  else
    _cc->reduce_on_shared_nodes( op);
  _cc->end_update_shared_nodes();
  
  if ( attr_inherited != attr) {
    _buf_window->delete_attribute( attr_inherited->name());
    _buf_window->init_done( false);
  }
}

Here is the caller graph for this function:

void serialize_window

(

COM::Window *

outwin

)

const

Create a serial window (with single pane) from the current window.

Definition at line 1353 of file Manifold_2.C.

References ACROSS_PANE, assign_global_nodeIDs(), COM_assertion, copy, i, iend, j, k, pm_begin(), pm_end(), REAL_PANE, size_of_faces(), and size_of_nodes().

Referenced by Rocsurf::serialize_mesh().

                                                                 {
  // Clearn up the output window
  outwin->delete_pane(0);

  // Build a renumbering of nodes
  std::vector<std::vector<int> >  nodes_gids;
  assign_global_nodeIDs( nodes_gids);

  Access_Mode mode = ACROSS_PANE;
  // Create a pane
  int nnodes=size_of_nodes( mode);
  outwin->set_size( "nc", 1, nnodes);

  double *coors;
  outwin->resize_array( "nc",1,(void**)&coors);

  // Mesh vertices
  int gid=0;
  // Loop through the panes to write the nodes
  PM_const_iterator it=pm_begin(), iend=pm_end();
  for ( ; it!=iend; ++it) {
    const COM::Pane &pn = *it->pane();
    const double *p = pn.coordinates();

    for ( int i=0, nn=pn.size_of_real_nodes(); i<nn; ++i) {
      if ( it->is_primary( i+1, mode)) {
        std::copy( &p[3*i], &p[3*i+3], &coors[3*gid]);
        ++gid;
      }
    }
  }
  COM_assertion( gid==nnodes);

  // Mesh triangles.
  int *tris;
  outwin->set_size( ":t3:", 1, size_of_faces(REAL_PANE));
  outwin->resize_array( ":t3:", 1, (void**)&tris);
  
  int i=0, k=0;
  for ( it=pm_begin(); it!=iend; ++it, ++i) {
    int fn=it->size_of_faces(REAL_PANE); if ( fn==0) continue;

    Element_node_enumerator ene( it->pane(), 1);

    for ( int f=0; f<fn; ++f, ++k, ene.next()) {
      for ( int j=0; j<3; ++j) {
        tris[3*k+j] = nodes_gids[i][ene[j]-1];
      }
    }
  }

  outwin->init_done();
}

Here is the call graph for this function:

Here is the caller graph for this function:

void shortest_edge_length

(

COM::Attribute *

lens

)

Obtain shortest edge length of incident edges of each node or element.

Definition at line 398 of file Manifold_2.C.

References COM_assertion_msg, COM_compatible_types(), COM_DOUBLE, compute_shortest_edgelen_elements(), and compute_shortest_edgelen_nodes().

                                          {
  COM_assertion_msg( lens && (lens->is_nodal() || lens->is_elemental()),
                     "Argument must be nodal or elemental attribute");
  COM_assertion_msg( lens->size_of_components()== 1 &&
                     COM_compatible_types(lens->data_type(), COM_DOUBLE),
                     "Argument must be double-precision scalars"); 

  if ( lens->is_nodal()) {
    compute_shortest_edgelen_nodes( lens);
  }
  else {
    compute_shortest_edgelen_elements( lens);   
  }
}

Here is the call graph for this function:

int size_of_edges

(

Access_Mode

mode

)

const

Obtain the number of edges.

Definition at line 1179 of file Manifold_2.C.

References iend, n, pm_begin(), and pm_end().

                                                        {
  int n = 0;
  // Loop through panes
  PM_const_iterator it=pm_begin(), iend=pm_end();
  for ( ; it != iend; ++it) {
    n += it->size_of_edges( mode);
  }

  return n;
}

Here is the call graph for this function:

int size_of_faces

(

Access_Mode

mode

)

const

Obtain the number of faces.

Definition at line 1143 of file Manifold_2.C.

References iend, n, pm_begin(), and pm_end().

Referenced by serialize_window().

                                                        {
  int n = 0;
  // Loop through panes
  PM_const_iterator it=pm_begin(), iend=pm_end();
  for ( ; it != iend; ++it) {
    n += it->size_of_faces( mode);
  }

  return n;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int size_of_nodes

(

Access_Mode

mode

)

const

Obtain the number of nodes (shared nodes are counted only once.

Definition at line 1132 of file Manifold_2.C.

References iend, n, pm_begin(), and pm_end().

Referenced by assign_global_nodeIDs(), and serialize_window().

                                                        {
  int n = 0;
  // Loop through panes
  PM_const_iterator it=pm_begin(), iend=pm_end();
  for ( ; it != iend; ++it) {
    n += it->size_of_nodes( mode);
  }
  return n;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int size_of_panes ( ) const

inline

Obtain the number of panes.

Definition at line 220 of file Manifold_2.h.

References _pms.

Referenced by assign_global_nodeIDs().

{ return _pms.size(); }

Here is the caller graph for this function:

int size_of_quadrilaterals

(

Access_Mode

mode

)

const

Obtain the number of quadrilaterals.

Definition at line 1167 of file Manifold_2.C.

References iend, n, pm_begin(), and pm_end().

                                                                 {
  int n = 0;
  // Loop through panes
  PM_const_iterator it=pm_begin(), iend=pm_end();
  for ( ; it != iend; ++it) {
    n += it->size_of_quadrilaterals( mode);
  }

  return n;
}

Here is the call graph for this function:

int size_of_triangles

(

Access_Mode

mode

)

const

Obtain the number of triangles.

Definition at line 1155 of file Manifold_2.C.

References iend, n, pm_begin(), and pm_end().

                                                            {
  int n = 0;
  // Loop through panes
  PM_const_iterator it=pm_begin(), iend=pm_end();
  for ( ; it != iend; ++it) {
    n += it->size_of_triangles( mode);
  }

  return n;
}

Here is the call graph for this function:

void update_bd_flags

(

const COM::Attribute *

flags

)

Update the flags for border faces.

Definition at line 541 of file Manifold_2.C.

References _buf_window, COM_assertion, COM_compatible_types(), COM_INT, i, iend, n, pm_begin(), and pm_end().

                                            {
  const COM::Attribute *flags_inherited = flags;
  COM_assertion( flags->size_of_components()== 1 &&
                 COM_compatible_types(flags->data_type(), COM_INT));

  // Allocate buffer arrays
  if ( flags->window()!=_buf_window)
    flags_inherited = _buf_window->inherit
      ( const_cast< COM::Attribute *>(flags), "faceflags__CNNTEMP", 
        false, true, NULL, 0);
  COM::Attribute *flg=_buf_window->new_attribute( "flags__PMTEMP", 
                                                  'p', COM_INT, 1, "");
  COM::Attribute *pconn_g=_buf_window->new_attribute( "pconn__PMTEMP", 
                                                      'p', COM_INT, 1, "");
  COM::Attribute *pconn_e=_buf_window->attribute( "pconn_e");

  // Fill in flags and pconn
  for ( PM_iterator it=pm_begin(), iend=pm_end(); it != iend; ++it) {
    COM::Pane *pn = const_cast<COM::Pane*>(it->pane());
    const int *flgs_face = reinterpret_cast<int *>
      (pn->attribute( flags_inherited->id())->pointer());

    COM::Attribute *flg_pn = pn->attribute( flg->id());
    int n = it->size_of_real_border_edges();
    flg_pn->set_size( n, 0);
    it->_bd_flgs.resize( n);

    int *flgs_bd = &it->_bd_flgs[0];
    _buf_window->set_array( flg->name(), pn->id(), flgs_bd);

    for ( int i=0; i<n; ++i) {
      Edge_ID eid=it->get_opposite_real_edge(Edge_ID(i+1, Edge_ID::BndID));
      
      flgs_bd[i] = flgs_face[eid.eid()-1];
    }

    // Construct pane-connectivity
    it->convert_pconn_edge2ghost( pn->attribute( pconn_e->id()), 
                                  pn->attribute( pconn_g->id()));
  }
  _buf_window->init_done(false);

  // Perform communication
  MAP::Rocmap::update_ghosts( flg, pconn_g);

  _buf_window->delete_attribute( pconn_g->name());
  _buf_window->delete_attribute( flg->name());
  if ( flags_inherited != flags)
    _buf_window->delete_attribute( flags_inherited->name());
  _buf_window->init_done(false);
}

Here is the call graph for this function:

void update_bd_normals	(	const COM::Attribute *	normals,
		bool	to_normalize = false
	)

Update the normals for border faces.

Definition at line 485 of file Manifold_2.C.

References _buf_window, COM_assertion, COM_compatible_types(), COM_DOUBLE, COM_INT, i, iend, n, Vector_3< Type >::normalize(), pm_begin(), and pm_end().

                                      {
  const COM::Attribute *normals_inherited = normals;
  COM_assertion( normals->size_of_components()== 3 &&
                 COM_compatible_types(normals->data_type(), COM_DOUBLE));

  // Allocate buffer arrays
  if ( normals->window()!=_buf_window)
    normals_inherited = _buf_window->inherit
      ( const_cast< COM::Attribute *>(normals), "facenormals__CNNTEMP", 
        false, true, NULL, 0);
  COM::Attribute *nrm=_buf_window->new_attribute( "normals__PMTEMP", 
                                                  'p', COM_DOUBLE, 3, "");
  COM::Attribute *pconn_g=_buf_window->new_attribute( "pconn__PMTEMP", 
                                                      'p', COM_INT, 1, "");
  COM::Attribute *pconn_e=_buf_window->attribute( "pconn_e");


  // Fill in normals and pconn
  for ( PM_iterator it=pm_begin(), iend=pm_end(); it != iend; ++it) {
    COM::Pane *pn = const_cast<COM::Pane*>(it->pane());
    const Vector_3<Real> *nrms_face = reinterpret_cast<Vector_3<Real> *>
      (pn->attribute( normals_inherited->id())->pointer());

    COM::Attribute *nrm_pn = pn->attribute( nrm->id());
    int n = it->size_of_real_border_edges();
    nrm_pn->set_size( n, 0);
    it->_bd_nrms.resize( n);

    Vector_3<Real> *nrms_bd = &it->_bd_nrms[0];
    _buf_window->set_array( nrm->name(), pn->id(), nrms_bd);

    for ( int i=0; i<n; ++i) {
      Edge_ID eid=it->get_opposite_real_edge(Edge_ID(i+1, Edge_ID::BndID));
      
      nrms_bd[i] = nrms_face[eid.eid()-1];
      if ( to_normalize) nrms_bd[i].normalize();
    }

    // Construct pane-connectivity
    it->convert_pconn_edge2ghost( pn->attribute( pconn_e->id()), 
                                  pn->attribute( pconn_g->id()));
  }
  _buf_window->init_done(false);

  // Perform communication
  MAP::Rocmap::update_ghosts( nrm, pconn_g);

  _buf_window->delete_attribute( pconn_g->name());
  _buf_window->delete_attribute( nrm->name());
  if ( normals_inherited != normals)
    _buf_window->delete_attribute( normals_inherited->name());
  _buf_window->init_done(false);
}

Here is the call graph for this function:

void update_bdedge_bitmap

(

const COM::Attribute *

bitmap

)

Update bitmap for border edges.

Definition at line 594 of file Manifold_2.C.

References _buf_window, COM_assertion, COM_CHAR, COM_compatible_types(), COM_INT, i, iend, n, pm_begin(), and pm_end().

                                                  {
  const COM::Attribute *bm_inherited = bitmap;
  COM_assertion( bm_inherited->size_of_components()== 1 &&
                 COM_compatible_types(bm_inherited->data_type(), COM_CHAR));

  // Allocate buffer arrays
  if ( bm_inherited->window()!=_buf_window)
    bm_inherited = _buf_window->inherit
      ( const_cast< COM::Attribute *>(bitmap), "facebm__CNNTEMP", 
        false, true, NULL, 0);
  COM::Attribute *bm=_buf_window->new_attribute( "bm__PMTEMP", 
                                                 'p', COM_CHAR, 1, "");
  COM::Attribute *pconn_g=_buf_window->new_attribute( "pconn__PMTEMP", 
                                                      'p', COM_INT, 1, "");
  COM::Attribute *pconn_e=_buf_window->attribute( "pconn_e");

  // Fill in bm and pconn
  for ( PM_iterator it=pm_begin(), iend=pm_end(); it != iend; ++it) {
    COM::Pane *pn = const_cast<COM::Pane*>(it->pane());
    const char *bms_face = reinterpret_cast<char *>
      (pn->attribute( bm_inherited->id())->pointer());

    COM::Attribute *bm_pn = pn->attribute( bm->id());
    int n = it->size_of_real_border_edges();
    bm_pn->set_size( n, 0);
    it->_bd_bm.resize( n);

    char *bms_bd = &it->_bd_bm[0];
    _buf_window->set_array( bm->name(), pn->id(), bms_bd);

    for ( int i=0; i<n; ++i) {
      Edge_ID eid=it->get_opposite_real_edge(Edge_ID(i+1, Edge_ID::BndID));
      
      bms_bd[i] = bms_face[eid.eid()-1] & (1<<eid.lid());
    }

    // Construct pane-connectivity
    it->convert_pconn_edge2ghost( pn->attribute( pconn_e->id()), 
                                  pn->attribute( pconn_g->id()));
  }
  _buf_window->init_done(false);

  // Perform communication
  MAP::Rocmap::update_ghosts( bm, pconn_g);

  _buf_window->delete_attribute( pconn_g->name());
  _buf_window->delete_attribute( bm->name());
  if ( bm_inherited != bitmap)
    _buf_window->delete_attribute( bm_inherited->name());
  _buf_window->init_done(false);
}

Here is the call graph for this function:

COM::Window* window ( )

inline

Obtain the underlying window object.

Definition at line 203 of file Manifold_2.h.

Referenced by Rocsurf::compute_edge_lengths().

{ return _buf_window; }

Here is the caller graph for this function:

const COM::Window* window ( ) const

inline

Definition at line 204 of file Manifold_2.h.

References _buf_window.

{ return _buf_window; }

Member Data Documentation

COM::Window* _buf_window

protected

Definition at line 360 of file Manifold_2.h.

Referenced by accumulate_bd_values(), compute_mcn(), compute_nodal_normals(), elements_to_nodes(), init(), init_communicator(), perturb_mesh(), reduce_on_shared_nodes(), update_bd_flags(), update_bd_normals(), update_bdedge_bitmap(), window(), and ~Window_manifold_2().

MAP::Pane_communicator* _cc

protected

Definition at line 364 of file Manifold_2.h.

Referenced by compute_nodal_normals(), elements_to_nodes(), init_communicator(), reduce_on_shared_nodes(), and ~Window_manifold_2().

int _pconn_nb

protected

Definition at line 365 of file Manifold_2.h.

Referenced by init(), and pconn_nblocks().

std::map< int, int> _pi_map

protected

Definition at line 363 of file Manifold_2.h.

Referenced by determine_counterparts(), determine_primaries(), get_pane_manifold(), and init().

std::vector< Pane_manifold_2> _pms

protected

Definition at line 361 of file Manifold_2.h.

Referenced by determine_counterparts(), determine_primaries(), get_pane_manifold(), init(), pm_begin(), pm_end(), and size_of_panes().

MPI_Op OP_BAND =MPI_BAND

static

Definition at line 353 of file Manifold_2.h.

MPI_Op OP_BOR =MPI_BOR

static

Definition at line 353 of file Manifold_2.h.

MPI_Op OP_DIFF =MPI_MINLOC

static

Definition at line 353 of file Manifold_2.h.

Referenced by reduce_on_shared_nodes().

MPI_Op OP_LAND =MPI_LAND

static

Definition at line 353 of file Manifold_2.h.

MPI_Op OP_LOR =MPI_LOR

static

Definition at line 353 of file Manifold_2.h.

SURF_BEGIN_NAMESPACE MPI_Op OP_MAX =MPI_MAX

static

Definition at line 353 of file Manifold_2.h.

Referenced by Rocmop::get_redist_safe_factor(), and Rocmop::identify_ridge_edges().

MPI_Op OP_MAXABS =MPI_MAXLOC

static

Definition at line 353 of file Manifold_2.h.

Referenced by perturb_mesh(), and reduce_on_shared_nodes().

MPI_Op OP_MIN =MPI_MIN

static

Definition at line 353 of file Manifold_2.h.

Referenced by compute_shortest_edgelen_nodes(), and Rocmop::identify_ridge_edges().

MPI_Op OP_PROD =MPI_PROD

static

Definition at line 353 of file Manifold_2.h.

MPI_Op OP_SUM =MPI_SUM

static

Definition at line 353 of file Manifold_2.h.

Referenced by elements_to_nodes(), Rocmop::redistribute_vertices_ridge(), and Rocmop::redistribute_vertices_smooth().

---

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

• Manifold_2.h
• compute_curvature.C
• Manifold_2.C