Rocsurf Class Reference

#include <Rocsurf.h>

Inheritance diagram for Rocsurf:

Collaboration diagram for Rocsurf:

Public Member Functions
	Rocsurf ()
virtual	~Rocsurf ()
virtual Window_manifold_2 *	manifold ()
	Obtain a reference to the manifold. More...
void	initialize (const COM::Attribute *pmesh)
	Constructs the communication patterns of a distributed mesh. More...
void	compute_normals (const COM::Attribute *mesh, COM::Attribute *nrm, const int *scheme=NULL)
	Computes nodal or elemental normals of a given window. More...
void	compute_mcn (COM::Attribute *mcn, COM::Attribute *lbmcn)
	Computes nodal or elemental normals of a given window. More...
void	serialize_mesh (const COM::Attribute *inmesh, COM::Attribute *outmesh)
	Serialize the mesh of a given window. More...
void	compute_edge_lengths (double *lave, double *lmin, double *lmax)
	Computes edge lengths of a given window. More...
void	elements_to_nodes (const COM::Attribute *elem_vals, COM::Attribute *nodal_vals, const COM::Attribute *mesh=NULL, const int *scheme=NULL, const COM::Attribute *elem_weights=NULL, COM::Attribute *nodal_weights=NULL)
	Computes nodal or elemental normals of a given window. More...

Static Public Member Functions
static void	load (const std::string &mname)
	Loads Rocsurf onto Roccom with a given module name. More...
static void	unload (const std::string &mname)
	Unloads Rocsurf from Roccom. More...
static void	interpolate_to_centers (const COM::Attribute *x, COM::Attribute *z)
	Interpolates nodal coordinates to element centers. More...
static void	integrate (const COM::Attribute *x, double *z)
	Integrate a function given by an elemental attribute over surface z is an array of size equal to number of components of x. More...
static void	compute_element_areas (COM::Attribute *areas, const COM::Attribute *pnts=NULL)
	Computes the area of each face of the surface mesh of window areas->window and saves the results in attribute areas. More...
static void	compute_element_normals (COM::Attribute *nrm, const int *to_normalize=NULL, const COM::Attribute *pnts=NULL)
	Computes elemental normals of a given window. More...
static void	compute_bounded_volumes (const COM::Attribute *old_location, const COM::Attribute *new_location, COM::Attribute *volumes, void *flag=NULL)
	Computes the volume bounded between two different locations of each face of the surface mesh of window volumes->window. More...
static void	compute_swept_volumes (const COM::Attribute *location, const COM::Attribute *disps, COM::Attribute *volumes, void *flag=NULL)
	Computes the swept volume by a given displacement of each face of the surface mesh of window volumes->window. More...
static void	compute_center (const COM::Attribute *mesh, Vector_3< double > &cnt)
	Computes the center of a body. More...
static void	compute_signed_volumes (const COM::Attribute *mesh, double *vol)
	Computes the signed volume of a body. More...

Protected Types
enum	{ SURF_COOKIE =7627873 }

Protected Member Functions
int	validate_object () const

Static Protected Member Functions
template<class T >
static void	normalize (T *a, int size) throw (int)

Protected Attributes
Window_manifold_2 *	_wm
int	_cookie

Static Protected Attributes
static const int	scheme_vals [] = {E2N_USER, E2N_ONE, E2N_AREA, E2N_ANGLE}

Detailed Description

Definition at line 41 of file Rocsurf.h.

Member Enumeration Documentation

anonymous enum

protected

Enumerator
SURF_COOKIE

Definition at line 162 of file Rocsurf.h.

{ SURF_COOKIE=7627873};

Constructor & Destructor Documentation

Rocsurf ( )

inline

Definition at line 44 of file Rocsurf.h.

Referenced by load().

: _wm(NULL), _cookie(SURF_COOKIE) {}

Here is the caller graph for this function:

~Rocsurf ( )

virtual

Definition at line 33 of file Rocsurf.C.

References _wm.

{ if (_wm) delete _wm; }

Member Function Documentation

void compute_bounded_volumes ( const COM::Attribute *  old_location, const COM::Attribute *  new_location, COM::Attribute *  volumes, void *  flag = NULL  )

static

Computes the volume bounded between two different locations of each face of the surface mesh of window volumes->window.

Typically, the two locations of the surface correspond to the surface at two different snapshots of a simulation.

Parameters

old_location	stores the old nodal coordinates.
new_location	stores the new nodal coordinates.
volumes	stores the bounded volume for each element.
If	flag is present, then only compute volume for elements whose corresponding value of the volume attribute was set to nonzero value.

Definition at line 108 of file compute_bounded_volumes.C.

References arrange(), get_face_volume(), i, j, Element_node_enumerator::next(), normalize_coor(), Element_node_vectors_k_const< Value >::set(), Element_node_enumerator::size_of_edges(), and volume().

Referenced by load().

                                                   {

  assert( element_volume != NULL && element_volume ->size_of_components() == 1); 
  assert( element_volume->window() == old_location->window());
  assert( element_volume->window() == new_location->window());

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

  Point_3<Real>      ps_face4[4];
  Point_3<Real>      ps_face3[3];
  Point_3<Real>      ps[8];

  // ps is used as a container for both the old and new coordinates
  // the following ordering convention is used:
  // the coordinates of the new surface occupy indexes 0 to 3
  // the coordinates of the old surface occupy indexes 4 to 7 
  // both surfaces have coordinates listed in the same order
  //   i.e. ps[0] and ps[4] are new and old coordinates for the same node
  // under these conventions, ps[3] and ps[7] are not used for triangular faces

  std::vector< COM::Pane*>::const_iterator it = panes.begin();
  // Loop through the elements of the pane.
  for (int i=0, local_npanes = panes.size(); i<local_npanes; ++i, ++it){ 
    const COM::Pane &pane = **it; 
    Real *ptr_ev = (Real *)(pane.attribute( element_volume->id())->pointer());
    const Point_3<Real> *ptr_new = 
      (const Point_3<Real>*)(pane.attribute( new_location->id())->pointer());
    const Point_3<Real> *ptr_old = 
      (const Point_3<Real>*)(pane.attribute( old_location->id())->pointer());

    Element_node_vectors_k_const<Point_3<Real> > ps_new, ps_old;

    Element_node_enumerator ene( &pane, 1); 
    for ( int j=pane.size_of_elements(); j>0; --j, ene.next(), ++ptr_ev) {
      if ( flag!=NULL && *ptr_ev==0.) continue;

      Real volume = 0;
      // if mesh is triangular, we have two triangular faces, 3 quadrilaterals
      ps_new.set( ptr_new, ene, 1);
      ps_old.set( ptr_old, ene, 1);

      ps[0]=ps_new[0];ps[1]=ps_new[1];ps[2]=ps_new[2];
      ps[4]=ps_old[0];ps[5]=ps_old[1];ps[6]=ps_old[2];

      if (ene.size_of_edges()==3) {
          
        if ( ps[0]==ps[4] && ps[1]==ps[5] && ps[2]==ps[6]) 
          { *ptr_ev = 0.; continue; }
        ps[3] = Point_3<Real>(0,0,0);
        normalize_coor( ps, 7, 6);

        // solid has two triangular faces
        arrange(ps_face3,ps,0,2,1);
        volume += get_face_volume(ps_face3, 3);
        arrange(ps_face3,ps,4,5,6);
        volume += get_face_volume(ps_face3, 3);
        // quadrilateral faces
        arrange(ps_face4,ps,0,4,6,2);
        volume += get_face_volume(ps_face4, 4);
      }
      else{  // if not triangular,  mesh is quadrilateral
        ps[3]=ps_new[3]; ps[7]=ps_old[3];
        if ( ps[0]==ps[4] && ps[1]==ps[5] && ps[2]==ps[6] && ps[3]==ps[7]) 
          { *ptr_ev = 0.; continue; }
        normalize_coor( ps, 8, 8);
        
        arrange(ps_face4,ps,0,3,2,1);
        volume += get_face_volume(ps_face4, 4);
        arrange(ps_face4,ps,4,5,6,7);
        volume += get_face_volume(ps_face4, 4);
        arrange(ps_face4,ps,3,7,6,2);
        volume += get_face_volume(ps_face4, 4);
        arrange(ps_face4,ps,0,4,7,3);
        volume += get_face_volume(ps_face4, 4);
      }
      // Two quarilateral faces are the same in either case
      arrange(ps_face4,ps,1,2,6,5);
      volume += get_face_volume(ps_face4, 4);
      arrange(ps_face4,ps,0,1,5,4);
      volume += get_face_volume(ps_face4, 4);
      
      volume /= 3.;
      *ptr_ev = -volume;
    } 
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void compute_center ( const COM::Attribute *  mesh, Vector_3< double > &  cnt  )

static

Computes the center of a body.

Definition at line 291 of file compute_bounded_volumes.C.

References COM_NC, COMMPI_Initialized(), i, j, and MPI_SUM.

Referenced by compute_signed_volumes().

                                                   {
  std::vector< const COM:: Pane*> panes;
  mesh->window() -> panes( panes);

  struct Accumulator {
    Accumulator() : cnt(Vector_3<Real>(0,0,0)), count(0) {}
    
    Vector_3<Real> cnt;
    double  count;
  };
  Accumulator global;

  std::vector< const COM::Pane*>::const_iterator it = panes.begin();
  // Loop through the elements of the pane.
  for (int i=0, local_npanes = panes.size(); i<local_npanes; ++i, ++it){ 
    const COM::Pane &pane = **it; 
    const Vector_3<Real> *ptr = 
      (const Vector_3<Real>*)(pane.attribute( COM::COM_NC)->pointer());

    for ( int j=pane.size_of_real_nodes(); j>0; --j, ++ptr) {
      global.cnt += *ptr;
      global.count += 1.;
    }
  }

  // Perform reduction on cnt and count
  Accumulator local=global;

  if ( COMMPI_Initialized()) {
    MPI_Allreduce( &local.cnt[0], &global.cnt[0], 4, MPI_DOUBLE, MPI_SUM, 
                   mesh->window()->get_communicator());
  }
  cnt = global.cnt/global.count;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void compute_edge_lengths	(	double *	lave,
		double *	lmin,
		double *	lmax
	)

Computes edge lengths of a given window.

Definition at line 87 of file Rocsurf.C.

References _wm, ACROSS_PANE, COMMPI_Initialized(), i, iend, Halfedge::is_border(), max(), min(), MPI_MAX, MPI_MIN, MPI_SUM, Halfedge::next(), Vector_3< Type >::norm(), Halfedge::opposite(), Window_manifold_2::pm_begin(), Window_manifold_2::pm_end(), Halfedge::tangent(), and Window_manifold_2::window().

Referenced by load(), and Rocprop::load().

                                                                            {

  Window_manifold_2::PM_iterator it=_wm->pm_begin(), iend=_wm->pm_end();

  double local_lmin=HUGE_VAL, local_lmax=0, local_lsum=0, local_weights=0;

  // Loop through the panes to identify strong edges
  for ( ; it!=iend; ++it) {
    for (int i=0, nf=it->size_of_real_faces(); i<nf; ++i) {
      Halfedge h=Halfedge( &*it, Edge_ID( i+1, 0), ACROSS_PANE), h0=h;
      do {
        Halfedge hopp=h.opposite();

        if ( hopp.is_border() || h < hopp) {
          double  l = h.tangent().norm();

          local_lmin = std::min( local_lmin, l);
          local_lmax = std::max( local_lmax, l);
          local_lsum += l;
          local_weights += 1;
        }
      } while ( (h=h.next())!=h0);
    }
  }

  double global_lmin=local_lmin, global_lmax=local_lmax, 
    global_lsum=local_lsum, global_weighs=local_weights;
  
  if ( COMMPI_Initialized()) {
    MPI_Comm comm = _wm->window()->get_communicator();
    MPI_Allreduce( &local_lmin, &global_lmin, 1, MPI_DOUBLE, MPI_MIN, comm);
    MPI_Allreduce( &local_lmax, &global_lmax, 1, MPI_DOUBLE, MPI_MAX, comm);
    MPI_Allreduce( &local_lsum, &global_lsum, 1, MPI_DOUBLE, MPI_SUM, comm);
    MPI_Allreduce( &local_weights, &global_weighs, 1, MPI_DOUBLE, MPI_SUM, comm);
  }

  if ( lave) *lave = (global_weighs>0)? (global_lsum / global_weighs) : 0.;
  if ( lmin) *lmin = global_lmin;
  if ( lmax) *lmax = global_lmax;
}

Here is the call graph for this function:

Here is the caller graph for this function:

SURF_BEGIN_NAMESPACE void compute_element_areas ( COM::Attribute *  areas, const COM::Attribute *  pnts = NULL  )

static

Computes the area of each face of the surface mesh of window areas->window and saves the results in attribute areas.

If pnts is present, then use it in place of the nodal coordinates

Definition at line 41 of file compute_element_areas.C.

References COM_assertion, COM_assertion_msg, COM_compatible_types(), COM_DOUBLE, COM_NC, i, j, k, Element_node_enumerator::next(), Element_node_vectors_k_const< Value >::set(), Element_node_enumerator::size_of_edges(), and Element_node_enumerator::size_of_nodes().

Referenced by load().

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

  std::vector< COM:: Pane*> panes;
  element_areas->window() -> panes( panes); 
  Element_node_vectors_k_const<Point_3<Real> > ps;
  Vector_2<Real> nc(0,0);

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

    const COM::Attribute *nc_pane = (pnts==NULL)?pane.attribute( COM::COM_NC):
      pane.attribute( pnts->id());
    COM::Attribute *a_pane = pane.attribute( element_areas->id());
    COM_assertion( pane.size_of_elements()==0 ||
                   nc_pane->stride()==3 && a_pane->stride()==1);

    const Point_3<Real> *pnts = (const Point_3<Real>*)(nc_pane->pointer()); 
    Real *ptr = (Real *)(a_pane->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(),++ptr) {
      Generic_element_2 e(ene.size_of_edges(), ene.size_of_nodes());
      ps.set( pnts, ene, 1);
      int size = e.get_num_gp();
      Real this_area = 0;

      for (int k = 0; k<size; k++){
        Real weight = e.get_gp_weight( k);
        e.get_gp_nat_coor(k, nc);
        Real jacobi_det = e.Jacobian_det(ps,nc);
        this_area += weight * jacobi_det;
      }
      *ptr = this_area;
    } 
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

SURF_BEGIN_NAMESPACE void compute_element_normals ( COM::Attribute *  nrm, const int *  to_normalize = NULL, const COM::Attribute *  pnts = NULL  )

static

Computes elemental normals of a given window.

Normalize the normals if to_normalize is NULL (default) or its value is nonzero. If pnts is present, then use it in place of the nodal coordinates

Definition at line 32 of file compute_element_normals.C.

References COM_assertion, COM_NC, Vector_3< Type >::cross_product(), i, j, Element_node_enumerator::next(), Vector_3< Type >::normalize(), Element_node_vectors_k_const< Value >::set(), Element_node_enumerator::size_of_edges(), and Element_node_enumerator::size_of_nodes().

Referenced by Window_manifold_2::compute_nodal_normals(), Window_manifold_2::compute_normals(), and load().

                                                                 {

  assert( elem_nrmls != NULL && elem_nrmls ->size_of_components() == 3); 

  std::vector< COM:: Pane*> panes;
  elem_nrmls->window() -> panes( panes); 
  Element_node_vectors_k_const<Point_3<Real> > ps;

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

  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 COM::Attribute *nc_pane = (pnts==NULL)?pane.attribute( COM::COM_NC):
      pane.attribute( pnts->id());
    COM_assertion( pane.size_of_elements()==0 || nc_pane->stride()==3);
    
    const Point_3<Real> *pnts = (const Point_3<Real>*)(nc_pane->pointer());
    Vector_3<Real> *ptr = (Vector_3<Real> *)
      (pane.attribute( elem_nrmls->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(),++ptr) {
      Generic_element_2 e(ene.size_of_edges(), ene.size_of_nodes());
      ps.set( pnts, ene, 1);
        
      e.Jacobian( ps, nc, J);
      *ptr = Vector_3<Real>::cross_product( J[0], J[1]);
      if ( to_normalize==NULL || *to_normalize) 
        ptr->normalize();
      else if ( e.size_of_edges()==3) // If triangle, reduce by half.
        (*ptr) *= 0.5;
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void compute_mcn	(	COM::Attribute *	mcn,
		COM::Attribute *	lbmcn
	)

Computes nodal or elemental normals of a given window.

Definition at line 63 of file Rocsurf.C.

References _wm, COM_assertion_msg, Window_manifold_2::compute_mcn(), and validate_object().

Referenced by load().

                                                {
  COM_assertion_msg( validate_object()==0, "Invalid object");

  COM_assertion_msg( _wm, "initialization must be called first before calling compute_mcn");
  
  _wm->compute_mcn( mcn, lbmcn);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void compute_normals	(	const COM::Attribute *	mesh,
		COM::Attribute *	nrm,
		const int *	scheme = NULL
	)

Computes nodal or elemental normals of a given window.

Definition at line 49 of file Rocsurf.C.

References _wm, COM_assertion_msg, Window_manifold_2::compute_normals(), initialize(), and validate_object().

Referenced by load().

                                                  {
  COM_assertion_msg( validate_object()==0, "Invalid object");

  if ( _wm == NULL) initialize( mesh);

  if ( scheme) 
    _wm->compute_normals( nrm, *scheme);
  else
    _wm->compute_normals( nrm);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void compute_signed_volumes ( const COM::Attribute *  mesh, double *  vol  )

static

Computes the signed volume of a body.

Definition at line 329 of file compute_bounded_volumes.C.

References COM_NC, compute_center(), get_face_volume(), i, j, Element_node_enumerator::next(), Element_node_vectors_k_const< Value >::set(), and Element_node_enumerator::size_of_edges().

Referenced by load().

                                                               {
  std::vector< const COM:: Pane*> panes;
  mesh->window() -> panes( panes);

  Vector_3<Real> cnt;
  // First, obtain the center
  compute_center( mesh, cnt);

  Point_3<Real>      normalized_face[4];

  *vol = 0;
  std::vector< const COM::Pane*>::const_iterator it = panes.begin();
  // Loop through the elements of the pane.
  for (int i=0, local_npanes = panes.size(); i<local_npanes; ++i, ++it){ 
    const COM::Pane &pane = **it; 
    const Point_3<Real> *ptr = 
      (const Point_3<Real>*)(pane.attribute( COM::COM_NC)->pointer());

    Element_node_vectors_k_const<Point_3<Real> > ps;

    Element_node_enumerator ene( &pane, 1); 
    for ( int j=pane.size_of_elements(); j>0; --j, ene.next()) {
      ps.set( ptr, ene, 1);

      normalized_face[0]=ps[0]-cnt; 
      normalized_face[1]=ps[1]-cnt;
      normalized_face[2]=ps[2]-cnt; 

      if (ene.size_of_edges()==3) {
        *vol += get_face_volume(normalized_face, 3);
      }
      else{  // if not triangular,  element is quadrilateral
        normalized_face[3]=ps[3]-cnt;
        *vol += get_face_volume(normalized_face, 4);
      }
    } 
  }
      
  // Divide the signed volume by 3.
  *vol /= 3.;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void compute_swept_volumes ( const COM::Attribute *  location, const COM::Attribute *  disps, COM::Attribute *  volumes, void *  flag = NULL  )

static

Computes the swept volume by a given displacement of each face of the surface mesh of window volumes->window.

Parameters

old_location	stores the nodal coordinates.
disps	stores the nodal displacement.
volumes	stores the swept volume for each element.
If	flag is present, then only compute volume for elements whose corresponding value of the volume attribute was set to nonzero value.

Definition at line 199 of file compute_bounded_volumes.C.

References arrange(), get_face_volume(), i, j, Element_node_enumerator::next(), normalize_coor(), Element_node_vectors_k_const< Value >::set(), Element_node_enumerator::size_of_edges(), and volume().

Referenced by load().

                                                 {

  assert( element_volume != NULL && element_volume ->size_of_components() == 1); 
  assert( element_volume->window() == location->window());
  assert( element_volume->window() == disps->window());

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

  Point_3<Real>      ps_face4[4];
  Point_3<Real>      ps_face3[3];
  Point_3<Real>      ps[8];

  // ps is used as a container for both the old and new coordinates
  // the following ordering convention is used:
  // the coordinates of the new surface occupy indexes 0 to 3
  // the coordinates of the old surface occupy indexes 4 to 7 
  // both surfaces have coordinates listed in the same order
  //   i.e. ps[0] and ps[4] are new and old coordinates for the same node
  // under these conventions, ps[3] and ps[7] are not used for triangular faces

  std::vector< COM::Pane*>::const_iterator it = panes.begin();
  // Loop through the elements of the pane.
  for (int i=0, local_npanes = panes.size(); i<local_npanes; ++i, ++it){ 
    const COM::Pane &pane = **it; 
    Real *ptr_ev = (Real *)(pane.attribute( element_volume->id())->pointer());
    const Point_3<Real> *ptr_pos = 
      (const Point_3<Real>*)(pane.attribute( location->id())->pointer());
    const Vector_3<Real> *ptr_disp = 
      (const Vector_3<Real>*)(pane.attribute( disps->id())->pointer());

    Element_node_vectors_k_const<Point_3<Real> > pnts;
    Element_node_vectors_k_const<Vector_3<Real> > ds;

    Element_node_enumerator ene( &pane, 1); 
    for ( int j=pane.size_of_elements(); j>0; --j, ene.next(), ++ptr_ev) {
      if ( flag!=NULL && *ptr_ev==0.) continue;

      Real volume = 0;
      // if mesh is triangular, we have two triangular faces, 3 quadrilaterals
      ds.set( ptr_disp, ene, 1);
      pnts.set( ptr_pos, ene, 1);

      ps[0]=pnts[0]+ds[0];ps[1]=pnts[1]+ds[1];ps[2]=pnts[2]+ds[2];
      ps[4]=pnts[0];ps[5]=pnts[1];ps[6]=pnts[2];

      if (ene.size_of_edges()==3) {
          
        if ( ps[0]==ps[4] && ps[1]==ps[5] && ps[2]==ps[6]) 
          { *ptr_ev = 0.; continue; }
        ps[3] = Point_3<Real>(0,0,0);
        normalize_coor( ps, 7, 6);

        // solid has two triangular faces
        arrange(ps_face3,ps,0,2,1);
        volume += get_face_volume(ps_face3, 3);
        arrange(ps_face3,ps,4,5,6);
        volume += get_face_volume(ps_face3, 3);
        // quadrilateral faces
        arrange(ps_face4,ps,0,4,6,2);
        volume += get_face_volume(ps_face4, 4);
      }
      else{  // if not triangular,  mesh is quadrilateral
        ps[3]=pnts[3]+ds[3]; ps[7]=pnts[3];
        if ( ps[0]==ps[4] && ps[1]==ps[5] && ps[2]==ps[6] && ps[3]==ps[7]) 
          { *ptr_ev = 0.; continue; }
        normalize_coor( ps, 8, 8);
        
        arrange(ps_face4,ps,0,3,2,1);
        volume += get_face_volume(ps_face4, 4);
        arrange(ps_face4,ps,4,5,6,7);
        volume += get_face_volume(ps_face4, 4);
        arrange(ps_face4,ps,3,7,6,2);
        volume += get_face_volume(ps_face4, 4);
        arrange(ps_face4,ps,0,4,7,3);
        volume += get_face_volume(ps_face4, 4);
      }
      // Two quarilateral faces are the same in either case
      arrange(ps_face4,ps,1,2,6,5);
      volume += get_face_volume(ps_face4, 4);
      arrange(ps_face4,ps,0,1,5,4);
      volume += get_face_volume(ps_face4, 4);
      
      volume /= 3.;
      *ptr_ev = -volume;
    } 
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void elements_to_nodes	(	const COM::Attribute *	elem_vals,
		COM::Attribute *	nodal_vals,
		const COM::Attribute *	mesh = NULL,
		const int *	scheme = NULL,
		const COM::Attribute *	elem_weights = NULL,
		COM::Attribute *	nodal_weights = NULL
	)

Computes nodal or elemental normals of a given window.

Definition at line 72 of file Rocsurf.C.

References _wm, COM_assertion_msg, E2N_AREA, Window_manifold_2::elements_to_nodes(), initialize(), and validate_object().

Referenced by load().

{
  COM_assertion_msg( validate_object()==0, "Invalid object");

  if ( _wm == NULL) initialize( mesh);

  _wm->elements_to_nodes( elem_vals, nodal_vals, scheme?*scheme:E2N_AREA,
                          elem_weights, nodal_weights);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void initialize

(

const COM::Attribute *

pmesh

)

Constructs the communication patterns of a distributed mesh.

If the input is pmesh, then use the given pconn. Otherwise, compute pconn.

Definition at line 35 of file Rocsurf.C.

References _wm, COM_assertion_msg, COM_MESH, COM_PMESH, Window_manifold_2::init_communicator(), and validate_object().

Referenced by compute_normals(), elements_to_nodes(), Rocprop::initialize(), load(), serialize_mesh(), and Rocmop::smoother_specific_init().

                                                  {
  COM_assertion_msg( validate_object()==0, "Invalid object");
  COM_assertion_msg( !mesh || mesh->id()==COM::COM_MESH || 
                     mesh->id()==COM::COM_PMESH,
                     "Input argument must be a mesh or pmesh");

  if ( _wm) delete _wm;

  _wm = new Window_manifold_2( const_cast<COM::Attribute*>(mesh));

  _wm->init_communicator();
}

Here is the call graph for this function:

Here is the caller graph for this function:

void integrate ( const COM::Attribute *  x, double *  z  )

static

Integrate a function given by an elemental attribute over surface z is an array of size equal to number of components of x.

Definition at line 88 of file compute_element_areas.C.

References COM_assertion, COM_assertion_msg, COM_compatible_types(), COM_DOUBLE, COM_NC, COMMPI_Initialized(), copy, i, j, k, MPI_SUM, Element_node_enumerator::next(), Element_node_vectors_k_const< Value >::set(), Element_node_enumerator::size_of_edges(), and Element_node_enumerator::size_of_nodes().

Referenced by load().

                                                         {

  COM_assertion_msg( x && x->is_elemental(),
                     "Argument must be elemental attribute");
  COM_assertion_msg( COM_compatible_types(x->data_type(), COM_DOUBLE),
                     "Argument must be double precision");

  const int ncomp = x->size_of_components();
  // Initialize output to 0.
  for ( int kk=0; kk<ncomp; ++kk) z[kk]=0.;

  std::vector< const COM:: Pane*> panes;
  x->window()-> panes( panes); 
  Element_node_vectors_k_const<Point_3<Real> > ps;
  Vector_2<Real> nc(0,0);

  std::vector< const 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; 
    // Assuming contiguous layout
    const COM::Attribute *nc_pane = pane.attribute( COM::COM_NC);
    const COM::Attribute *x_pane = pane.attribute( x->id());
    COM_assertion( pane.size_of_elements()==0 ||
                   nc_pane->stride()==3 && x_pane->stride()==ncomp);

    const Point_3<Real> *pnts = (const Point_3<Real>*)(nc_pane->pointer()); 
    const Real *xptr = (Real *)(x_pane->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(), xptr+=ncomp) {
      Generic_element_2 e(ene.size_of_edges(), ene.size_of_nodes());
      ps.set( pnts, ene, 1);
      int size = e.get_num_gp();

      for (int k = 0; k<size; k++){
        Real weight = e.get_gp_weight( k);
        e.get_gp_nat_coor(k, nc);
        Real jacobi_det = e.Jacobian_det(ps,nc);

        for ( int kk=0; kk<ncomp; ++kk) 
          z[kk] += weight * jacobi_det * xptr[kk];
      }
    } 
  }

  if ( COMMPI_Initialized()) {
    // Perform reduction on all processros within the communicator.
    std::vector<double> lval(ncomp); 
    std::copy( z, z+ncomp, lval.begin());
    MPI_Allreduce( &lval[0], z, ncomp, MPI_DOUBLE, MPI_SUM, 
                   x->window()->get_communicator());
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void interpolate_to_centers ( const COM::Attribute *  x, COM::Attribute *  z  )

static

Interpolates nodal coordinates to element centers.

Definition at line 100 of file interpolate_to_centers.C.

References COM_DOUBLE, COM_DOUBLE_PRECISION, i, and j.

Referenced by load().

                                                      {
  assert( x->is_nodal() && z->is_elemental() 
          && x->size_of_components() == z->size_of_components());
  assert( x->data_type() == COM_DOUBLE || 
          x->data_type() == COM_DOUBLE_PRECISION); 
  assert( z->data_type() == COM_DOUBLE || 
          z->data_type() == COM_DOUBLE_PRECISION); 

  std::vector<const COM::Pane*> xpanes;
  std::vector<COM::Pane*> zpanes;

  x->window()->panes(xpanes);
  z->window()->panes(zpanes);

  std::vector<COM::Pane*>::iterator zit, zend;
  std::vector<const COM::Pane*>::const_iterator xit;

  const int ndim = x->size_of_components();
  // Loop through all the panes.
  for( zit = zpanes.begin(), zend = zpanes.end(), xit = xpanes.begin();
       zit != zend; ++zit, ++xit) {
    //Loop for each dimension.
    for(int i = 0; i < ndim; ++i) {
      COM::Attribute *z_pa = (*zit)->attribute(z->id()+((ndim>1)?i+1:0));
      Real *zval = reinterpret_cast<Real *>(z_pa->pointer());
      int zstrd=z_pa->stride();

      const COM::Attribute *x_pa = (*xit)->attribute(x->id()+((ndim>1)?i+1:0));
      const Real *xval = reinterpret_cast<const Real *>(x_pa->pointer());
        
      Nodal_scalar_const_2d<Real>  X(x_pa->stride(), 0);
      Element_node_enumerator     ene( *xit, 1);
      Field<Nodal_scalar_const_2d<Real> > f( X, xval, ene);
        
      for (int j=(*xit)->size_of_elements(); j>0; --j, ene.next(), zval+=zstrd)
        Generic_element_2( ene.size_of_edges(), ene.size_of_nodes()).
          interpolate_to_center( f, zval);
    }
  }
}

Here is the caller graph for this function:

void load ( const std::string &  mname )

static

Loads Rocsurf onto Roccom with a given module name.

Definition at line 139 of file Rocsurf.C.

References COM_DOUBLE, COM_INT, COM_INTEGER, COM_METADATA, COM_new_attribute(), COM_new_window(), COM_RAWDATA, COM_set_array_const(), COM_set_function(), COM_set_member_function(), COM_set_object(), COM_VOID, COM_window_init_done(), compute_bounded_volumes(), compute_edge_lengths(), compute_element_areas(), compute_element_normals(), compute_mcn(), compute_normals(), compute_signed_volumes(), compute_swept_volumes(), E2N_ANGLE, E2N_AREA, E2N_ONE, E2N_USER, elements_to_nodes(), initialize(), integrate(), interpolate_to_centers(), Rocsurf(), scheme_vals, and serialize_mesh().

Referenced by Rocsurf_load_module(), rocsurf_load_module(), ROCSURF_LOAD_MODULE(), rocsurf_load_module_(), and ROCSURF_LOAD_MODULE_().

                                          {
  Rocsurf *surf = new Rocsurf();

  COM_new_window( mname.c_str());

  std::string glb=mname+".global";

  COM_new_attribute( glb.c_str(), 'w', COM_VOID, 1, "");
  COM_set_object( glb.c_str(), 0, surf);

  COM_Type types[7];

  types[0] = COM_METADATA; types[1] = COM_METADATA; 
  types[2] = COM_METADATA; types[3] = COM_VOID;
  COM_set_function( (mname+".interpolate_to_centers").c_str(),
                    (Func_ptr)interpolate_to_centers, "io", types);

  COM_set_function( (mname+".compute_element_areas").c_str(), 
                    (Func_ptr)compute_element_areas, "oI", types);
  
  COM_set_function( (mname+".compute_bounded_volumes").c_str(), 
                    (Func_ptr)compute_bounded_volumes, "iioI", types);
  
  COM_set_function( (mname+".compute_swept_volumes").c_str(), 
                    (Func_ptr)compute_swept_volumes, "iioI", types);
  
  types[0] = COM_METADATA; types[1] = COM_DOUBLE; 
  COM_set_function( (mname+".integrate").c_str(), 
                    (Func_ptr)integrate, "io", types);
  
  COM_set_function( (mname+".compute_signed_volumes").c_str(), 
                    (Func_ptr)compute_signed_volumes, "io", types);

  types[1] = COM_INTEGER; 
  COM_set_function( (mname+".compute_element_normals").c_str(), 
                    (Func_ptr)compute_element_normals, "oII", types);


  types[0] = COM_RAWDATA; types[1] = types[2] = COM_METADATA;
  COM_set_member_function( (mname+".initialize").c_str(), 
                           (Member_func_ptr)(&Rocsurf::initialize), 
                           glb.c_str(), "bi", types);

  types[3] = COM_INT; 
  COM_set_member_function( (mname+".compute_normals").c_str(), 
                           (Member_func_ptr)(&Rocsurf::compute_normals), 
                           glb.c_str(), "bioI", types);
  

  COM_set_member_function( (mname+".compute_mcn").c_str(), 
                           (Member_func_ptr)(&Rocsurf::compute_mcn), 
                           glb.c_str(), "boo", types);

  types[3] = types[5] = types[6] = COM_METADATA; types[4] = COM_INT; 
  COM_set_member_function( (mname+".elements_to_nodes").c_str(),
                           (Member_func_ptr)(&Rocsurf::elements_to_nodes),
                           glb.c_str(), "bioiIIO", types);

  COM_new_attribute((mname+".E2N_USER").c_str(), 'w', COM_INT, 1, "");
  COM_set_array_const((mname+".E2N_USER").c_str(), 0, &scheme_vals[E2N_USER]);
  COM_new_attribute((mname+".E2N_ONE").c_str(), 'w', COM_INT, 1, "");
  COM_set_array_const((mname+".E2N_ONE").c_str(), 0, &scheme_vals[E2N_ONE]);
  COM_new_attribute((mname+".E2N_AREA").c_str(), 'w', COM_INT, 1, "");
  COM_set_array_const((mname+".E2N_AREA").c_str(), 0, &scheme_vals[E2N_AREA]);
  COM_new_attribute((mname+".E2N_ANGLE").c_str(), 'w', COM_INT, 1, "");
  COM_set_array_const((mname+".E2N_ANGLE").c_str(), 0, &scheme_vals[E2N_ANGLE]);

  types[1] = types[2] = types[3] = COM_DOUBLE;
  COM_set_member_function( (mname+".compute_edge_lengths").c_str(),
                           (Member_func_ptr)(&Rocsurf::compute_edge_lengths),
                           glb.c_str(), "boOO", types);

  types[1] = types[2] = COM_METADATA;
  COM_set_member_function( (mname+".serialize_mesh").c_str(),
                           (Member_func_ptr)(&Rocsurf::serialize_mesh),
                           glb.c_str(), "bio", types);

  COM_window_init_done( mname.c_str());
}

Here is the call graph for this function:

Here is the caller graph for this function:

virtual Window_manifold_2* manifold ( )

inlinevirtual

Obtain a reference to the manifold.

Definition at line 115 of file Rocsurf.h.

References _wm.

{ return _wm; }

static void normalize ( T *  a, int  size  ) throw ( int )

inlinestaticprotected

Definition at line 147 of file Rocsurf.h.

References i, and sqrt().

                                                    {
    T tmp(0);
    for (int i=0; i<size; ++i) tmp += a[i]*a[i]; 
    
    if ( tmp == 0) return;
    tmp = std::sqrt(tmp);
    for (int i=0; i<size; ++i) a[i] /= tmp;
  }

Here is the call graph for this function:

void serialize_mesh	(	const COM::Attribute *	inmesh,
		COM::Attribute *	outmesh
	)

Serialize the mesh of a given window.

Definition at line 128 of file Rocsurf.C.

References _wm, COM_assertion_msg, initialize(), Window_manifold_2::serialize_window(), and validate_object().

Referenced by load().

                                                                               {
  COM_assertion_msg( validate_object()==0, "Invalid object");

  if ( _wm == NULL) initialize( inmesh);

  COM::Window *outwin = outmesh->window();

  // Serialize input mesh and put into output mesh
  _wm->serialize_window( outwin);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void unload ( const std::string &  mname )

static

Unloads Rocsurf from Roccom.

Definition at line 219 of file Rocsurf.C.

References COM_delete_window(), and COM_get_object().

Referenced by Rocsurf_unload_module(), rocsurf_unload_module(), ROCSURF_UNLOAD_MODULE(), rocsurf_unload_module_(), and ROCSURF_UNLOAD_MODULE_().

                                            {
  Rocsurf *surf;
  std::string glb=mname+".global";

  COM_get_object( glb.c_str(), 0, &surf);
  delete surf;

  COM_delete_window( mname.c_str());
}

Here is the call graph for this function:

Here is the caller graph for this function:

int validate_object ( ) const

inlineprotected

Definition at line 156 of file Rocsurf.h.

References _cookie, and SURF_COOKIE.

Referenced by compute_mcn(), compute_normals(), elements_to_nodes(), initialize(), serialize_mesh(), and Rocprop::validate_object().

                              {
    if ( _cookie != SURF_COOKIE) return -1;
    else return COM_Object::validate_object();
  }

Here is the caller graph for this function:

Member Data Documentation

int _cookie

protected

Definition at line 165 of file Rocsurf.h.

Referenced by validate_object().

Window_manifold_2* _wm

protected

Definition at line 163 of file Rocsurf.h.

Referenced by compute_edge_lengths(), compute_mcn(), compute_normals(), elements_to_nodes(), initialize(), manifold(), serialize_mesh(), and ~Rocsurf().

SURF_BEGIN_NAMESPACE const int scheme_vals = {E2N_USER, E2N_ONE, E2N_AREA, E2N_ANGLE}

staticprotected

Definition at line 164 of file Rocsurf.h.

Referenced by load().

---

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

• Rocsurf.h
• compute_bounded_volumes.C
• compute_element_areas.C
• compute_element_normals.C
• interpolate_to_centers.C
• Rocsurf.C