RFC_Pane_base Class Reference

The base implementation of RFC_Pane. More...

#include <RFC_Window_base.h>

Inheritance diagram for RFC_Pane_base:

Collaboration diagram for RFC_Pane_base:

Classes
class	COM_Pane_friend
struct	Edge_ID
	A local ID of an edge. More...

Public Types
typedef RFC_Pane_base	Self
typedef COM::Pane	Base
typedef COM::Attribute	Attribute
typedef Base::Size	Size
typedef RFC::Real	Real
typedef std::pair< int, int >	V2b
	Pane id and local boundary id. More...
typedef std::map< int, V2b >	V2b_table
	From node id to its corresponding map. More...
typedef std::vector< int >	B2v
	From local boundary ids to node ids. More...
typedef std::map< int, B2v >	B2v_table
	From pane id to its corresponding mapping. More...

Public Member Functions
	RFC_Pane_base (Base *b, int color)
	A constructor. More...
void	init ()
virtual	~RFC_Pane_base ()
	The default destructor. More...
Base *	base ()
	The id of its base COM::Pane object. More...
const Base *	base () const
int	id () const
bool	is_master () const
	Is this pane a master copy? More...
bool	is_replicate () const
	Is this pane not a master copy? More...
bool	is_quadratic () const
	Does this pane contain quadratic elements? More...
bool	is_border_node (int i) const
	Is a give node on the boundary of the pane? More...
bool	is_isolated_node (int i) const
	Is a give node an isolated node not belong to any element? More...
bool	coincident (int i, int j) const
	Report whether the two given nodes are coincident. More...
int	size_of_nodes () const
	The total number of nodes in the pane. More...
int	size_of_faces () const
	The total number of faces in the pane. More...
int	size_of_isolated_nodes () const
int	size_of_border_nodes () const
Edge_ID	get_edge_id (const int face_lid, const int vertex_lid) const
	Get the edge id within a given face. More...
int	size_of_subnodes () const
	The total number of nodes in the subdivision of the pane. More...
int	size_of_subfaces () const
	The total number of faces in the subdivision of the pane. More...
Real *	pointer (int i)
	Get the address of a given attribute with id i. More...
const Real *	pointer (int i) const
bool	is_primary_node (const int vid) const
	Is the node with given local id a primary one? More...
int	size_of_primary_nodes () const
	Get total number of primary nodes contained in the pane. More...
const Point_3 &	get_point (int id) const
	Get the physical coordinates of the node with given local id. More...
const Point_3 &	get_point (int id, int) const
const Real *	coordinates () const
Point_3	get_point_of_subnode (int id) const
Bbox_3	get_bounding_box () const
	Get the bounding box of the pane. More...
int	color () const
	The color of the parent window (BLUE or GREEN). More...
int	parent_type_of_subnode (int) const
	Determine the parent type of a subnode of given tyep. More...
int	get_parent_node (int) const
	Get the local parent node id of a given subnode. More...
int	get_parent_face (int id) const
	Get the local parent face id of a given subface. More...
template<class Point >
void	normalize_nat_coor (int idx, int e, Point &nc) const
void	get_host_element_of_subnode (int i, Element_node_enumerator &ene, Point_2 &nc) const
void	get_host_element_of_subface (int i, Element_node_enumerator &ene) const
void	get_nat_coor_in_element (const int eid, const int lid, Point_2 &nc) const
	Take a subface id and a local subnode id, return the natual coordinates of the subnode within the parent element. More...
void	get_nat_coor_in_element (const int sn_id, Element_node_enumerator &ene, Point_2 &nc) const
	Take a subnode id and an element, return the natrual coordinates within the element. More...
std::pair< const COM::Connectivity *, int >	get_element (int face_id) const
	Get the connectivity object and the id within the connectivity object for a given element. More...
const Node_ID &	get_subnode_counterpart (int i) const
const Face_ID &	get_subface_counterpart (int i) const
int	get_lvid (const Element_node_enumerator &ene, const int v) const

Protected Member Functions
void	comp_nat_coors ()
	Compute the natural coordinates. More...
void	build_v2b_from_b2v (const RFC_Window_base *w)
	Build pane connectivity. More...
void	write_tec_ij (std::ostream &, const COM::Attribute *a=0) const
void	write_tec_tri (std::ostream &, const COM::Connectivity &, const COM::Attribute *a=0) const
void	write_tec_mixed (std::ostream &, const std::vector< const COM::Connectivity * > &, const COM::Attribute *a=0) const
void	write_tec_sub (std::ostream &) const
void	write_tec_ascii (std::ostream &os, const COM::Attribute *attr=0) const
void	write_binary (std::ostream &os) const
void	read_binary (std::istream &is, std::vector< int > *b2v_all=NULL, COM::Pane *p=NULL)
void	register_sdv_attributes (const std::string &wname) const
void	read_rocin (const std::string &sdv_wname, const std::string &parent_wname="", COM::Pane *p=NULL)
	Read in using Rocin. More...

Protected Attributes
Base *	_base
	Reference to its base object. More...
bool	_is_master
	Is the pane a master copy? More...
bool	_quadratic
	Does it contain quadratic elements? More...
std::vector< bool >	_is_border
	Is a node on border? More...
std::vector< bool >	_is_isolated
	Is a node isolated? More...
int	_n_border
int	_n_isolated
V2b_table	_v2b_table
B2v_table	_b2v_table
std::vector< Edge_ID >	_subnode_parents
	Edge ids of parents. More...
std::vector< Point_2S >	_subnode_nat_coors
	Natual coordinates in the parent face. More...
std::vector< Point_2S >	_subnode_normalized_nc
	Natual coordinates in the parent face. More...
std::vector< int >	_subnode_subID
	Sub-node ID of nodes in the pane. More...
std::vector< Node_ID >	_subnode_counterparts
	Ids of counterparts of subnodes. More...
std::vector< Three_tuple< int > >	_subfaces
std::vector< int >	_subface_parents
	Face ids of the parents of the subfaces. More...
std::vector< int >	_subface_offsets
	Offsets of first subfaces contained in a face. More...
std::vector< Face_ID >	_subface_counterparts
	Ids of counterparts of faces. More...
std::vector< Three_tuple < Point_2S > >	_subface_nat_coors
	Element connectivity of the subfaces. More...

Private Member Functions
	RFC_Pane_base ()
	RFC_Pane_base (const Self &)
Self &	operator= (const Self &)

Private Attributes
int	_color
	Is a node on border? More...
std::vector< const COM::Connectivity * >	_elem_conns
std::vector< int >	_elem_offsets

Friends
class	RFC_Window_base
template<class _Pane >
class	RFC_Window_derived

Detailed Description

The base implementation of RFC_Pane.

RFC_Pane_base is built on top of COM::Pane, which encapsulates the nodal coordinates, element connectivity, and attributes of a pane. RFC_Pane_base contains a reference to a COM::Pane object, and also stores a subdivision of a pane, and the pane connectivities for the nodes in the input mesh. Each node and each face in the subdivision has a counterpart in another window, and RFC_Pane_base also stores the ids of counterparts.

If a node is a border node, it can have multiple instances, and the one with the smallest global id among non-isolated-node instances is the primary copy.

For each pair of adjacent panes, we define a numbering system for their coincident nodes, which are numbered from 0 to the number of coincident nodes minus one. We refer to these ids as boundary ids. The number system in the adjacent pane is said to define the remote boundary ids corresponding to this pane.

We use two data structures to store pane connectivity information: The first one, V2b_table, stores mapping from node ids (within this pane) to the remote boundary ids of their primary copoes. V2b is a mapping from node ids to a pair <pane id, REMOTE boundary id>. The second data structure is B2v_table, which is a mapping from pane ids to B2v objects, where a B2v object is a dynamic array each of whose entries contains a local node id and whose indices correspond to the local boundary ids for these nodes. Therefore, a B2v objects contains a mapping from local boundary ids to local node ids for a specific adjacent pane, and there is a B2v object for every adjacent pane. Note that it is possible that a pane is adjacent to itself in the case where a "branch-cut" exists, and in this case V2b_table can contain an entry for the pane itself.

To find the node id of the primary copy for a local node, one must use the local V2b_table and the remote B2v_table. For example, to locate the node id in pane p for a local node v, one could use pane(v2b_table[v].first).b2v_table[my_pane_id][v2b_table[v].second]. One should, however, check that v2b_table.find(v)!=v2b_table.end() and v2b_table[v].find(p.id())!=v2b_table[v].end().

See Also

RFC_Window_base RFC_Window_derived

Definition at line 153 of file RFC_Window_base.h.

Member Typedef Documentation

typedef COM::Attribute Attribute

Definition at line 157 of file RFC_Window_base.h.

typedef std::vector<int> B2v

From local boundary ids to node ids.

Definition at line 193 of file RFC_Window_base.h.

typedef std::map<int, B2v> B2v_table

From pane id to its corresponding mapping.

Definition at line 195 of file RFC_Window_base.h.

typedef COM::Pane Base

Definition at line 156 of file RFC_Window_base.h.

typedef RFC::Real Real

Definition at line 159 of file RFC_Window_base.h.

typedef RFC_Pane_base Self

Definition at line 155 of file RFC_Window_base.h.

typedef Base::Size Size

Definition at line 158 of file RFC_Window_base.h.

typedef std::pair<int,int> V2b

Pane id and local boundary id.

Definition at line 189 of file RFC_Window_base.h.

typedef std::map<int, V2b> V2b_table

From node id to its corresponding map.

Definition at line 191 of file RFC_Window_base.h.

Constructor & Destructor Documentation

RFC_BEGIN_NAME_SPACE RFC_Pane_base	(	Base *	b,
		int	color
	)

A constructor.

Parameters

b	the base COM::Pane object.
color	the color of the parent window (BLUE or GREEN).

Definition at line 39 of file RFC_Window_base.C.

  : _base(b), _is_master(true), _quadratic(false), 
    _n_border(0), _n_isolated(0), _color(color) {}

virtual ~RFC_Pane_base ( )

inlinevirtual

The default destructor.

Definition at line 203 of file RFC_Window_base.h.

{}

RFC_Pane_base ( )

private

RFC_Pane_base ( const Self &  )

private

Member Function Documentation

Base* base ( )

inline

The id of its base COM::Pane object.

Definition at line 206 of file RFC_Window_base.h.

References _base.

Referenced by comp_nat_coors(), Overlay::convert_nat_coordinates(), Transfer_base::interpolate_fe(), Transfer_base::multiply_mass_mat_and_x(), RFC_Window_transfer::replicate_metadata(), and Vertex_set::Vertex_set().

{ return _base; }

Here is the caller graph for this function:

const Base* base ( ) const

inline

Definition at line 207 of file RFC_Window_base.h.

References _base.

{ return _base; }

void build_v2b_from_b2v ( const RFC_Window_base *  w )

protected

Build pane connectivity.

Definition at line 220 of file RFC_Window_base.C.

References _b2v_table, _v2b_table, i, iend, is_isolated_node(), RFC_Window_base::pane(), and RFC_assertion.

Referenced by RFC_Window_base::build_pc_tables().

                                                           {
  //`Loop through the B2v_table
  for ( B2v_table::iterator 
          it=_b2v_table.begin(), iend=_b2v_table.end(); it != iend; ++it) {
    for ( int i=0, size=it->second.size(); i<size; ++i) {
      if ( it->first > id() && !is_isolated_node(it->second[i])) continue;

      std::pair<int,int> p(it->first, i);
      if ( it->first==id()) {
        RFC_assertion( (i&1)==1 && it->second[i-1] < it->second[i] ||
                       (i&1)==0 && it->second[i] < it->second[i+1]);
        if ( (i&1)==0 || is_isolated_node( it->second[i-1]))
          continue;
        --p.second;
      }
      else { 
        const RFC_Pane_base &pane = w->pane( it->first);
        if ( pane.is_isolated_node( pane._b2v_table.find(id())->second[i]))
          continue;
      }

      if ( _v2b_table.find( it->second[i]) == _v2b_table.end())
        _v2b_table[it->second[i]] = p;
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool coincident	(	int	i,
		int	j
	)		const

Report whether the two given nodes are coincident.

Definition at line 71 of file RFC_Window_base.C.

References _b2v_table, _v2b_table, and RFC_assertion.

Referenced by get_lvid().

                                               {
  if ( v1==v2) return true;
  V2b_table::const_iterator it1 = _v2b_table.find( v1);
  V2b_table::const_iterator it2 = _v2b_table.find( v2);

  if ( it1 == _v2b_table.end() && it2 != _v2b_table.end())
    return it2->second.first == id() && 
      _b2v_table.find( id())->second[it2->second.second] == v1;
  else if ( it1 != _v2b_table.end() && it2 == _v2b_table.end())
    return it1->second.first == id() && 
      _b2v_table.find( id())->second[it1->second.second] == v2;
  else if ( it1 != _v2b_table.end() && it2 != _v2b_table.end()) {
    RFC_assertion( it1->second.first==id() && it2->second.first==id());
    B2v_table::const_iterator bit=_b2v_table.find( id());
    return bit->second[it1->second.second]==bit->second[it2->second.second];
  }
  else 
    return false;
}

Here is the caller graph for this function:

int color ( ) const

inline

The color of the parent window (BLUE or GREEN).

Definition at line 273 of file RFC_Window_base.h.

References _color.

Referenced by RFC_Pane_overlay::create_overlay_data().

{ return _color; }

Here is the caller graph for this function:

void comp_nat_coors ( )

protected

Compute the natural coordinates.

Definition at line 327 of file RFC_Window_base.C.

References _base, _subface_nat_coors, _subface_parents, _subfaces, _subnode_normalized_nc, _subnode_parents, _subnode_subID, base(), get_host_element_of_subface(), get_nat_coor_in_element(), i, Element_node_enumerator::id(), j, Element_node_enumerator::next(), Element_node_enumerator::pane(), parent_type_of_subnode(), PARENT_VERTEX, size_of_nodes(), size_of_subfaces(), and size_of_subnodes().

Referenced by RFC_Window_base::export_window(), read_binary(), and read_rocin().

                              {
  int nsn=size_of_subnodes();
  _subnode_normalized_nc.resize( nsn);
  _subnode_subID.resize( size_of_nodes());

  // Initialize _subnode_normalized_nc.
  for ( int i=0; i<nsn; ++i) {
    int f=_subnode_parents[i].face_id;
    Element_node_enumerator ene( _base, f);

    Point_2 p; get_nat_coor_in_element( i+1, ene, p);
    _subnode_normalized_nc[i] = Point_2S(p[0], p[1]);

    // Assign sub-node ID for each vertex in input mesh
    if (parent_type_of_subnode( i+1)==PARENT_VERTEX) {
      int vid = ene[_subnode_parents[i].edge_id];
      _subnode_subID[ vid-1] = i+1;
    }
  }
  
  int nsf=size_of_subfaces();
  _subface_nat_coors.resize( nsf);
  // Initialize _subface_nat_coors.
  Element_node_enumerator ene( base(), 1);
  for ( int i=0; i<nsf; ++i) {
    if ( ene.id() != _subface_parents[i]) {
      ene.next();
      if ( ene.pane()==NULL || ene.id() != _subface_parents[i]) 
        get_host_element_of_subface( i+1, ene);
    }
    Point_2 p;
    for ( int j=0; j<3; ++j) {
      get_nat_coor_in_element( _subfaces[i][j], ene, p);
      _subface_nat_coors[i][j] = Point_2S(p[0], p[1]);
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

const Real* coordinates ( ) const

inline

Definition at line 266 of file RFC_Window_base.h.

References _base.

Referenced by RFC_Pane_transfer::coordinates(), and get_point_of_subnode().

{ return _base->coordinates(); }

Here is the caller graph for this function:

Bbox_3 get_bounding_box

(

)

const

Get the bounding box of the pane.

Definition at line 152 of file RFC_Window_base.C.

References get_point(), i, and size_of_nodes().

                                      {
  Bbox_3 b;
  for ( int i=1, size=size_of_nodes(); i<=size; ++i) 
    b += Bbox_3(get_point( i));
  return b;
}

Here is the call graph for this function:

RFC_Pane_base::Edge_ID get_edge_id	(	const int	face_lid,
		const int	vertex_lid
	)		const

Get the edge id within a given face.

Definition at line 160 of file RFC_Window_base.C.

References _base, _elem_conns, k, and RFC_assertion.

                                                                          {
  if ( _base->is_structured()) {
    Element_node_enumerator ene( _base, face_lid, (COM::Connectivity *)NULL);
    for ( int k=0; k<4; ++k)
      if ( ene[k] == vertex_lid) return Edge_ID( face_lid, k);
    RFC_assertion(false); abort(); 
  }
  else {
    for ( std::vector<const COM::Connectivity*>::const_iterator
            it = _elem_conns.begin(); it != _elem_conns.end(); ++it) {
      const int ne = (*it)->size_of_edges_pe();
      if ( face_lid > int((*it)->index_offset()) && 
           face_lid <= int((*it)->index_offset()+(*it)->size_of_elements())) {
        Element_node_enumerator ene(_base, face_lid-(*it)->index_offset(), *it);
        
        for ( int k=0; k<ne; ++k)
          if ( ene[k] == vertex_lid) return Edge_ID(face_lid,k);
        RFC_assertion(false); abort(); 
      }
    }
  }
  return Edge_ID(face_lid,-1);
}

std::pair< const COM::Connectivity*, int> get_element ( int  face_id ) const

inline

Get the connectivity object and the id within the connectivity object for a given element.

Definition at line 342 of file RFC_Window_base.h.

References _elem_conns, and _elem_offsets.

                                                                        {
    const int* p = std::lower_bound( &*_elem_offsets.begin(),
                                     &*_elem_offsets.end(), face_id)-1;
    return std::make_pair( _elem_conns[p-&_elem_offsets[0]],
                           face_id-_elem_offsets[*p]);
  }

void get_host_element_of_subface ( int  i, Element_node_enumerator &  ene  ) const

inline

Definition at line 322 of file RFC_Window_base.h.

References _base, _subface_parents, Element_node_enumerator::id(), and Element_node_enumerator::pane().

Referenced by comp_nat_coors(), Transfer_base::init_load_vector(), and Transfer_base::transfer_2f().

                                                                          {
    int f=_subface_parents[i-1];
    if ( ene.pane() != _base || ene.id() != f) 
      ene = Element_node_enumerator( _base, f);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

void get_host_element_of_subnode ( int  i, Element_node_enumerator &  ene, Point_2 &  nc  ) const

inline

Definition at line 312 of file RFC_Window_base.h.

References _base, _subnode_normalized_nc, _subnode_parents, Element_node_enumerator::id(), and Element_node_enumerator::pane().

Referenced by Transfer_base::interpolate_fe().

                                                  {
    int f=_subnode_parents[i-1].face_id;
    if ( ene.pane() != _base || ene.id() != f) 
      ene = Element_node_enumerator( _base, f);
    const Point_2S &p=_subnode_normalized_nc[i-1]; 
    nc[0]=p[0]; nc[1]=p[1];
  }

Here is the call graph for this function:

Here is the caller graph for this function:

int get_lvid	(	const Element_node_enumerator &	ene,
		const int	v
	)		const

Definition at line 185 of file RFC_Window_base.C.

References coincident(), i, j, RFC_assertion, Element_node_enumerator::size_of_nodes(), and Element_node_enumerator::vertex().

Referenced by Overlay::convert_nat_coordinates(), and get_nat_coor_in_element().

                                              {
  int i = ene.vertex( vid);
  if ( i<0) {
    // Resort to a more expensive method.
    for ( int j=ene.size_of_nodes()-1; j>=0; --j) {
      if ( coincident(vid, ene[j])) { i = j; }
    }
    RFC_assertion( i>=0);
  }
  return i;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void get_nat_coor_in_element ( const int  eid, const int  lid, Point_2 &  nc  ) const

inline

Take a subface id and a local subnode id, return the natual coordinates of the subnode within the parent element.

Definition at line 330 of file RFC_Window_base.h.

References _subface_nat_coors.

Referenced by comp_nat_coors(), Transfer_base::compute_load_vector_wra(), get_point_of_subnode(), and Transfer_base::integrate_subface().

                                                                                 {
    const Point_2S &p=_subface_nat_coors[eid-1][lid];
    nc[0] = p[0]; nc[1]=p[1];
  }

Here is the caller graph for this function:

void get_nat_coor_in_element	(	const int	sn_id,
		Element_node_enumerator &	ene,
		Point_2 &	nc
	)		const

Take a subnode id and an element, return the natrual coordinates within the element.

Definition at line 92 of file RFC_Window_base.C.

References _base, _subnode_nat_coors, _subnode_parents, RFC_Pane_base::Edge_ID::edge_id, RFC_Pane_base::Edge_ID::face_id, get_lvid(), i, Element_node_enumerator::id(), normalize_nat_coor(), RFC_assertion, and Element_node_enumerator::size_of_edges().

                                                                          {
  RFC_assertion( sn_id >= 1 && sn_id <= int(_subnode_parents.size()));

  const Point_2S &p = _subnode_nat_coors[ sn_id-1];
  const Edge_ID &eid = _subnode_parents[ sn_id-1];

  if ( eid.face_id == ene.id()) {
    nc[0]=p[0]; nc[1]=p[1];
    normalize_nat_coor( eid.edge_id, ene.size_of_edges(), nc);
  }
  else {
    nc[0] = 1.-p[0]; nc[1]=0;
    int vid = Element_node_enumerator(_base,eid.face_id)[eid.edge_id];

    int i = get_lvid(ene, vid)-1;

    int num_edges = ene.size_of_edges();
    if ( i<0) i=num_edges-1;
    normalize_nat_coor( i, num_edges, nc);
  }
}

Here is the call graph for this function:

int get_parent_face ( int  id ) const

inline

Get the local parent face id of a given subface.

Definition at line 282 of file RFC_Window_base.h.

References _subface_parents.

Referenced by Transfer_base::transfer_2f().

{ return _subface_parents[ id-1]; }

Here is the caller graph for this function:

int get_parent_node

(

int

id

)

const

Get the local parent node id of a given subnode.

Precondition: The parent type is PARENT_VERTEX.

Definition at line 130 of file RFC_Window_base.C.

References _base, _subnode_parents, RFC_Pane_base::Edge_ID::edge_id, and RFC_Pane_base::Edge_ID::face_id.

Referenced by Transfer_base::interpolate_fe().

                                            {
  const Edge_ID &eid=_subnode_parents[ id-1];
  Element_node_enumerator ene(_base, eid.face_id);

  return ene[eid.edge_id];  
}

Here is the caller graph for this function:

const Point_3& get_point ( int  id ) const

inline

Get the physical coordinates of the node with given local id.

Definition at line 258 of file RFC_Window_base.h.

References _base, and RFC_assertion.

Referenced by get_bounding_box(), RFC_Pane_overlay::get_point(), and Nodal_coor_const::get_value().

                                          {
    RFC_assertion( sizeof( Point_3) == 3*sizeof( Real));
    return *reinterpret_cast<const Point_3*>(_base->coordinates()+3*(id-1));
  }

Here is the caller graph for this function:

const Point_3& get_point ( int  id, int    ) const

inline

Definition at line 262 of file RFC_Window_base.h.

References _base, id(), and RFC_assertion.

                                               {
    RFC_assertion( sizeof( Point_3) == 3*sizeof( Real));
    return *reinterpret_cast<const Point_3*>(_base->coordinates()+3*id);
  }

Here is the call graph for this function:

Point_3 get_point_of_subnode

(

int

id

)

const

Definition at line 138 of file RFC_Window_base.C.

References _base, _subnode_parents, coordinates(), get_nat_coor_in_element(), Element_node_enumerator::size_of_edges(), and Element_node_enumerator::size_of_nodes().

Referenced by register_sdv_attributes(), and write_tec_sub().

                                                {
  const int fid = _subnode_parents[i-1].face_id;
  Element_node_enumerator ene( _base, fid);
  Point_2 nc; get_nat_coor_in_element( i, ene, nc);

  Nodal_coor_const coors;
  Field< const Nodal_coor_const, Element_node_enumerator> 
    ps( coors, coordinates(), ene);

  return SURF::Generic_element_2( ene.size_of_edges(), 
                                  ene.size_of_nodes()).interpolate(ps, nc);
}

Here is the call graph for this function:

Here is the caller graph for this function:

const Face_ID& get_subface_counterpart ( int  i ) const

inline

Definition at line 352 of file RFC_Window_base.h.

References _subface_counterparts, and RFC_assertion.

                                                       { 
    RFC_assertion( i>=1 && i<=(int)_subface_counterparts.size());
    return _subface_counterparts[i-1];
  }

const Node_ID& get_subnode_counterpart ( int  i ) const

inline

Definition at line 348 of file RFC_Window_base.h.

References _subnode_counterparts, and RFC_assertion.

Referenced by Transfer_base::interpolate_fe().

                                                       { 
    RFC_assertion( i>=1 && i<=(int)_subnode_counterparts.size());
    return _subnode_counterparts[i-1];
  }

Here is the caller graph for this function:

int id ( ) const

inline

Definition at line 208 of file RFC_Window_base.h.

References _base.

Referenced by Overlay::count_subnodes(), RFC_Window_overlay::detect_features(), RFC_Pane_overlay::determine_counterparts(), RFC_Window_base::export_window(), get_point(), RFC_Window_derived< _Pane >::get_primary(), Transfer_base::get_src_pane(), Transfer_base::get_trg_pane(), Transfer_base::init_load_vector(), Overlay::insert_node_in_blue_edge(), Transfer_base::interpolate_fe(), Overlay::intersect_blue_with_green(), Overlay::intersect_link(), Overlay::match_features_0(), Overlay::number_a_subnode(), Overlay::number_subfaces(), RFC_Window_overlay::print_features(), read_rocin(), register_sdv_attributes(), RFC_Window_transfer::replicate_data(), and Transfer_base::transfer_2f().

{ return _base->id(); }

Here is the caller graph for this function:

void init

(

)

Definition at line 44 of file RFC_Window_base.C.

References _base, _elem_conns, _elem_offsets, _is_border, _is_isolated, _n_border, _n_isolated, _quadratic, i, and n.

Referenced by RFC_Window_transfer::init_recv_buffer().

                    {
  
  // Determine whether the pane has quadratic elements
  if ( !_base->is_structured()) {
    _base->elements( _elem_conns);
    _elem_offsets.reserve( _elem_conns.size());

    for ( std::vector<const COM::Connectivity*>::const_iterator
            it = _elem_conns.begin(); it != _elem_conns.end(); ++it) {
      _elem_offsets.push_back( (*it)->index_offset());
      const int ne = (*it)->size_of_edges_pe();
      const int nn = (*it)->size_of_nodes_pe();
      if ( nn > ne) _quadratic = true;
    }
  }

  MAP::Pane_boundary pb( _base);
  pb.determine_border_nodes( _is_border, _is_isolated);

  for ( int i=0, n=_is_border.size(); i<n; ++i) 
  { _n_border += _is_border[i]; _n_isolated += _is_isolated[i]; }
}

Here is the caller graph for this function:

bool is_border_node ( int  i ) const

inline

Is a give node on the boundary of the pane?

Definition at line 217 of file RFC_Window_base.h.

References _is_border, RFC_assertion, and size_of_nodes().

Referenced by RFC_Window_derived< _Pane >::get_primary(), and is_primary_node().

  { RFC_assertion( i>=1 && i<= size_of_nodes()); return _is_border[i-1]; }

Here is the call graph for this function:

Here is the caller graph for this function:

bool is_isolated_node ( int  i ) const

inline

Is a give node an isolated node not belong to any element?

Definition at line 220 of file RFC_Window_base.h.

References _is_isolated, RFC_assertion, and size_of_nodes().

Referenced by build_v2b_from_b2v(), RFC_Window_derived< _Pane >::get_primary(), and is_primary_node().

  { RFC_assertion( i>=1 && i<= size_of_nodes()); return _is_isolated[i-1]; }

Here is the call graph for this function:

Here is the caller graph for this function:

bool is_master ( ) const

inline

Is this pane a master copy?

Definition at line 211 of file RFC_Window_base.h.

References _is_master.

Referenced by RFC_Window_overlay::delete_overlay_data(), RFC_Window_overlay::evaluate_normals(), RFC_Window_base::write_tec_ascii(), and RFC_Window_base::write_tec_sub().

{ return _is_master; }

Here is the caller graph for this function:

bool is_primary_node

(

const int

vid

)

const

Is the node with given local id a primary one?

Definition at line 202 of file RFC_Window_base.C.

References _v2b_table, is_border_node(), is_isolated_node(), and RFC_assertion.

Referenced by size_of_primary_nodes().

                                                   {
  if ( !is_border_node(vid) && !is_isolated_node(vid)) return true;
  V2b_table::const_iterator it = _v2b_table.find( vid);
  RFC_assertion( it != _v2b_table.end() || !is_isolated_node( vid));
  return ( it == _v2b_table.end());
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool is_quadratic ( ) const

inline

Does this pane contain quadratic elements?

Definition at line 215 of file RFC_Window_base.h.

References _quadratic.

Referenced by Transfer_base::interpolate_fe(), and RFC_Window_overlay::print_features().

{ return _quadratic; }

Here is the caller graph for this function:

bool is_replicate ( ) const

inline

Is this pane not a master copy?

Definition at line 213 of file RFC_Window_base.h.

References _is_master.

{ return !_is_master; }

void normalize_nat_coor ( int  idx, int  e, Point &  nc  ) const

inline

Normailize the natural coordinates.

Parameters

idx	the index of an edge of an element.
e	the number of edges fo an element
nc	the natural of a point in the element which where the edge idx is its first edge.

Definition at line 291 of file RFC_Window_base.h.

References RFC_assertion.

Referenced by Overlay::convert_nat_coordinates(), and get_nat_coor_in_element().

                                                            {
    if( e == 3) {
      switch( idx) {
      case 0: return; 
      case 1: nc = Point( 1.-nc[0]-nc[1], nc[0]); return;
      case 2: nc = Point( nc[1], 1.-nc[0]-nc[1]); return;
      default: RFC_assertion( false);
      }
    }
    else {
      switch( idx) {
      case 0: return; 
      case 1: nc = Point( 1-nc[1], nc[0]); return;
      case 2: nc = Point( 1-nc[0], 1-nc[1]); return; 
      case 3: nc = Point( nc[1], 1-nc[0]); return;
      default: RFC_assertion( false);
      }
    }
  }

Here is the caller graph for this function:

Self& operator= ( const Self &  )

private

int parent_type_of_subnode

(

int

id

)

const

Determine the parent type of a subnode of given tyep.

Parameters

id	the local id of the subnode (starting from 1).

Definition at line 118 of file RFC_Window_base.C.

References _subnode_nat_coors, PARENT_EDGE, PARENT_FACE, and PARENT_VERTEX.

Referenced by comp_nat_coors(), and Transfer_base::interpolate_fe().

                                                   {
  const Point_2S &nc = _subnode_nat_coors[ id-1];
  if ( nc[0]==0 && nc[1]==0)
    return PARENT_VERTEX;
  if ( nc[1]==0)
    return PARENT_EDGE;
  return PARENT_FACE;
}

Here is the caller graph for this function:

Real* pointer ( int  i )

inline

Get the address of a given attribute with id i.

Definition at line 245 of file RFC_Window_base.h.

References _base.

Referenced by RFC_Pane_transfer::pointer().

  { return (Real*)_base->attribute(i)->pointer(); }

Here is the caller graph for this function:

const Real* pointer ( int  i ) const

inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Definition at line 248 of file RFC_Window_base.h.

References _base.

  { return (Real*)_base->attribute(i)->pointer(); }

void read_binary ( std::istream &  is, std::vector< int > *  b2v_all = NULL, COM::Pane *  p = NULL  )

protected

Definition at line 163 of file RFC_Window_base_IO_binary.C.

References _b2v_table, _base, _subface_counterparts, _subface_offsets, _subface_parents, _subfaces, _subnode_counterparts, _subnode_nat_coors, _subnode_parents, _v2b_table, COM_NC, comp_nat_coors(), i, j, n, read(), RFC_assertion, RFC_assertion_code, size_of_faces(), size_of_nodes(), and swap_endian().

Referenced by RFC_Window_transfer::init_recv_buffer(), and RFC_Window_base::read_sdv().

                                                                       {

  COM_Pane_friend *pn = (COM_Pane_friend*)pn_in;
  RFC_assertion( sizeof(int)==4);
  RFC_assertion( sizeof(Real)==8);

  int t1, t2;
  
  read( is, t1); // For detecting big or small endian
  bool need_swap = (t1 != 1);
  if ( need_swap) swap_endian( t1);
  RFC_assertion( t1 == 1);
  Real version;
  is.read( (char*)&version, sizeof(Real));
  if ( need_swap) swap_endian( version);
  RFC_assertion( version == 3.);

  // Read in the color and the id of the pane.
  read( is, t1); read( is, t2); 
  if ( need_swap) { swap_endian( t1); swap_endian( t2); }
  
  // #nodes and #faces
  read( is, t1); read( is, t2);
  if ( need_swap) { swap_endian( t1); swap_endian( t2); }
  if ( pn != NULL) pn->set_size( pn->attribute(COM::COM_NC), t1, 0);
  else 
    RFC_assertion( t1 == size_of_nodes() && t2 == size_of_faces());
  _subface_offsets.resize( t2);

  // Nodal coordinates of the pane
  {
    int n=3*_base->size_of_nodes();
    std::vector< Real> buf( n);
    is.read( (char*)&buf.front(), n*sizeof(Real));
  }

  // Read in number of element types.
  int ntypes, is_structured=false;
  read( is, ntypes); if ( need_swap) { swap_endian( ntypes); }
  for ( int i=0; i<ntypes; ++i) {
    read( is, t1); read( is, t2);
    if ( need_swap) { swap_endian( t1); swap_endian( t2); }

    if ( t1 == 2) { // Structured mesh
      is_structured=true;
      RFC_assertion( t2==1);
      int dims[2];
      read( is, dims[0]); read( is, dims[1]);
      if ( need_swap) { swap_endian( dims[0]); swap_endian( dims[1]); }
      if ( pn != NULL) {
        int *t = &dims[0];
        COM::Connectivity *conn = pn->connectivity( ":st2:");
        pn->reinit_conn( conn, COM::Pane::OP_SET, &t, 0, 0);
      }
    }
    else { // Unstructured mesh
      int n=t1*t2;
      if ( pn) {
        int *buf=NULL;
        std::string elem;
        // Create a new Connectivity object in the Pane
        switch (t1) {
        case 3: elem=":t3:"; break;
        case 4: elem=":q4:"; break;
        case 6: elem=":t6:"; break;
        case 8: elem=":q8:"; break;
        case 9: elem=":q9:"; break;
        default: RFC_assertion(false);
        }
        // Insert a connectivity
        COM::Connectivity *conn=pn->connectivity( elem);
        pn->set_size( conn, t2, 0);
        pn->reinit_conn( conn, COM::Pane::OP_RESIZE, &buf, 0, 0);

        is.read( (char*)buf, n*sizeof(int));
        if ( need_swap) for ( int j=0; j<n; ++j) swap_endian( buf[j]);
      }
      else {
        int t;
        for ( int i=0; i<n; ++i) is.read( (char*)&t, sizeof(int));
      }
    }
  }

  // Pane connectivity of input mesh
  read( is, t1); t2 = size_of_nodes();
  if ( need_swap) { swap_endian( t1); }
  if ( b2v_all) b2v_all->reserve(t1);
  for ( int i=0; i<t1; ++i) {
    int pane_id, n;
    read( is, pane_id); read( is, n);
    if ( need_swap) { swap_endian( pane_id); swap_endian( n); }
    B2v &b2v = _b2v_table[pane_id];
    b2v.resize( n);
    is.read( (char*)&b2v[0], n*sizeof(b2v[0]));
    if ( need_swap) for ( int j=0; j<n; ++j) swap_endian( b2v[j]);
    RFC_assertion_code( for ( int j=0; j<n; ++j) 
                        RFC_assertion( b2v[j]>=1 && b2v[j]<=t2));
    if ( b2v_all)  { 
      b2v_all->push_back( pane_id); b2v_all->push_back( n); 
      b2v_all->insert( b2v_all->end(), b2v.begin(), b2v.end());
    }
  }

  read( is, t1); if ( need_swap) { swap_endian( t1); }
  for ( int i=0; i<t1; ++i) {
    int n1,n2,n3;
    read( is, n1);  if ( need_swap) { swap_endian( n1); }
    read( is, n2);  if ( need_swap) { swap_endian( n2); }
    read( is, n3);  if ( need_swap) { swap_endian( n3); }

    _v2b_table[n1] = std::make_pair( n2, n3);
  }

  read( is, t1); read( is, t2);
  if ( need_swap) { swap_endian( t1); swap_endian( t2); }
  _subnode_parents.resize( t1);
  _subnode_nat_coors.resize( t1);
  _subnode_counterparts.resize( t1);
  _subfaces.resize( t2);
  _subface_parents.resize( t2);
  _subface_counterparts.resize( t2);

  // Read in the subnodes.
  int n=_subnode_parents.size(); 
  RFC_assertion( sizeof(_subnode_parents[0])==8);
  is.read( (char*)&_subnode_parents[0], n*sizeof(_subnode_parents[0]));
  if ( need_swap)
    for ( int j=0; j<n; ++j) {
      swap_endian( _subnode_parents[j].face_id);
      swap_endian( _subnode_parents[j].edge_id);
    }

  is.read( (char*)&_subnode_nat_coors[0], 
           n*sizeof(_subnode_nat_coors[0]));
  if ( need_swap)
    for ( int j=0; j<n; ++j) {
      swap_endian( _subnode_nat_coors[j][0]);
      swap_endian( _subnode_nat_coors[j][1]);
    }

  is.read( (char*)&_subnode_counterparts[0], 
           n*sizeof(_subnode_counterparts[0]));
  if ( need_swap)
    for ( int j=0; j<n; ++j) {
      swap_endian( _subnode_counterparts[j].pane_id);
      swap_endian( _subnode_counterparts[j].node_id);
    }

  n = t2;
  // Read in the subfaces.
  is.read( (char*)&_subfaces[0], n*sizeof(_subfaces[0]));
  if ( need_swap)
    for ( int j=0; j<n; ++j) {
      swap_endian( _subfaces[j][0]);
      swap_endian( _subfaces[j][1]);
      swap_endian( _subfaces[j][2]);
    }
  is.read( (char*)&_subface_parents[0], n*sizeof(_subface_parents[0]));
  if ( need_swap)
    for ( int j=0; j<n; ++j) {
      swap_endian( _subface_parents[j]);
    }
  is.read( (char*)&_subface_counterparts[0], 
           t2*sizeof(_subface_counterparts[0]));
  if ( need_swap)
    for ( int j=0; j<n; ++j) {
      swap_endian( _subface_counterparts[j].pane_id);
      swap_endian( _subface_counterparts[j].face_id);
    }

  // Read in the offset of sub-faces.
  _subface_offsets.resize( size_of_faces()+1);
  n = _subface_offsets.size();
  is.read( (char*)&_subface_offsets[0], sizeof(int)*n);
  if ( need_swap) for ( int j=0; j<n; ++j) swap_endian( _subface_offsets[j]);

  RFC_assertion( _subface_offsets[size_of_faces()] == 
                 int(_subfaces.size()));

  read( is, t1);
  if ( need_swap) { swap_endian( t1); }
  RFC_assertion( t1 ==int(_subnode_parents.size()+_subfaces.size())); // Checksum

  comp_nat_coors();
}

Here is the call graph for this function:

Here is the caller graph for this function:

void read_rocin ( const std::string &  sdv_wname, const std::string &  parent_wname = "", COM::Pane *  p = NULL  )

protected

Read in using Rocin.

Parameters

sdv_wname	subdivision window name
parent_wname	parent window name
p	parent pane ID base

Definition at line 169 of file RFC_Window_base_IO.C.

References _subface_counterparts, _subface_nat_coors, _subface_offsets, _subface_parents, _subfaces, _subnode_counterparts, _subnode_nat_coors, _subnode_normalized_nc, _subnode_parents, _subnode_subID, _v2b_table, COM_copy_array(), COM_get_attribute_handle(), COM_get_roccom(), COM_get_size(), COM_PMESH, comp_nat_coors(), i, id(), size_of_faces(), and size_of_nodes().

Referenced by RFC_Window_transfer::init_recv_buffer().

                              {

  const int pid = id();

  // If pn_base is not NULL, then inherit from parent pane.
  if ( pn_base) {
    // Obtain the mesh object in the corresponding pane in the parent window
    COM::Roccom_base *rcom = COM_get_roccom();
    int win_handle = rcom->get_window_handle( parent_wname.c_str());
    COM::Window *parent_win = rcom->get_window_object(win_handle);
    
    COM::Attribute *mesh = parent_win->pane(pid).attribute( COM::COM_PMESH);

    // Clone the mesh from parent pane onto pn_base.
    ((Pane_friend*)pn_base)->inherit( mesh, "", COM::Pane::INHERIT_CLONE, 0);
  }

  // Obtain v2b_table
  int nv2b; const int *v2b_ptr;
  COM_get_size( (sdv_wname+".v2b").c_str(), pid, &nv2b);
  COM_get_array_const( (sdv_wname+".v2b").c_str(), pid, &v2b_ptr);

  for ( int i=0; i<nv2b; i+=3)
    _v2b_table[ v2b_ptr[i]] = std::make_pair( v2b_ptr[i+1], v2b_ptr[i+2]);

  // Obtain b2v mapping
  int nb2v; const int *b2v_ptr;
  COM_get_size( (sdv_wname+".b2v").c_str(), pid, &nb2v);

  COM_get_array_const( (sdv_wname+".b2v").c_str(), pid, &b2v_ptr);

  int nsubn, nsubf;
  COM_get_size( (sdv_wname+".nc").c_str(), pid, &nsubn);
  COM_get_size( (sdv_wname+".:t3").c_str(), pid, &nsubf);

  _subfaces.resize( nsubf);
  COM_copy_array( (sdv_wname+".:t3").c_str(), pid, &_subfaces[0]);

  if ( COM_get_attribute_handle((sdv_wname+".sn_parent_fcID").c_str())>0) {
    // This is the new HDF file format!

    // Obtain subnode_parents, subnode_natcoor, and subnode_counterparts
    _subnode_parents.resize( nsubn);
    COM_copy_array( (sdv_wname+".sn_parent_fcID").c_str(), 
                    pid, &_subnode_parents[0].face_id, 2);
    _subnode_normalized_nc.resize( nsubn);
    COM_copy_array( (sdv_wname+".sn_parent_ncs").c_str(), 
                    pid, &_subnode_normalized_nc[0], 2);
    _subnode_subID.resize( size_of_nodes());
    COM_copy_array( (sdv_wname+".sn_subID").c_str(), 
                    pid, &_subnode_subID[0], 1);
    
    COM_copy_array( (sdv_wname+".sn_permu_edID").c_str(), 
                    pid, &_subnode_parents[0].edge_id, 2);
    _subnode_nat_coors.resize( nsubn);
    COM_copy_array( (sdv_wname+".sn_permu_ncs").c_str(), 
                    pid, &_subnode_nat_coors[0][0], 2);

    _subnode_counterparts.resize( nsubn);
    COM_copy_array( (sdv_wname+".sn_cntpt_pnID").c_str(), 
                    pid, &_subnode_counterparts[0].pane_id, 2);
    COM_copy_array( (sdv_wname+".sn_cntpt_ndID").c_str(), 
                    pid, &_subnode_counterparts[0].node_id, 2);

    _subface_parents.resize( nsubf);
    COM_copy_array( (sdv_wname+".sf_parent").c_str(), pid, 
                    &_subface_parents[0]);
    
    _subface_counterparts.resize( nsubf);
    COM_copy_array( (sdv_wname+".sf_cntpt_pnID").c_str(), pid, 
                    &_subface_counterparts[0].pane_id, 2);
    COM_copy_array( (sdv_wname+".sf_cntpt_fcID").c_str(), pid, 
                    &_subface_counterparts[0].face_id, 2);

    _subface_nat_coors.resize( nsubf);
    COM_copy_array( (sdv_wname+".sf_ncs").c_str(), pid, 
                    &_subface_nat_coors[0], 6);

    // Obtain subface_offsets
    _subface_offsets.resize( size_of_faces()+1);
    COM_copy_array( (sdv_wname+".sf_offset").c_str(), pid, 
                    &_subface_offsets[0]);
    _subface_offsets[size_of_faces()] = nsubf;
  }
  else { // This is old file format
    // Obtain subnode_parents, subnode_natcoor, and subnode_counterparts
    _subnode_parents.resize( nsubn);
    COM_copy_array( (sdv_wname+".sn_parents_fcID").c_str(), 
                    pid, &_subnode_parents[0].face_id, 2);
    COM_copy_array( (sdv_wname+".sn_parents_edID").c_str(), 
                    pid, &_subnode_parents[0].edge_id, 2);
    
    _subnode_nat_coors.resize( nsubn);
    COM_copy_array( (sdv_wname+".sn_xi").c_str(), 
                    pid, &_subnode_nat_coors[0][0], 2);
    COM_copy_array( (sdv_wname+".sn_eta").c_str(), 
                    pid, &_subnode_nat_coors[0][1], 2);

    _subnode_counterparts.resize( nsubn);
    COM_copy_array( (sdv_wname+".sn_cntpt_pnID").c_str(), 
                    pid, &_subnode_counterparts[0].pane_id, 2);
    COM_copy_array( (sdv_wname+".sn_cntpt_ndID").c_str(), 
                    pid, &_subnode_counterparts[0].node_id, 2);

    _subface_parents.resize( nsubf);
    COM_copy_array( (sdv_wname+".sf_parents").c_str(), pid, 
                    &_subface_parents[0]);
    
    _subface_counterparts.resize( nsubf);
    COM_copy_array( (sdv_wname+".sf_cntpt_pnID").c_str(), pid, 
                    &_subface_counterparts[0].pane_id, 2);
    COM_copy_array( (sdv_wname+".sf_cntpt_fcID").c_str(), pid, 
                    &_subface_counterparts[0].face_id, 2);

    // Obtain subface_offsets
    _subface_offsets.resize( size_of_faces()+1);
    COM_copy_array( (sdv_wname+".sf_offsets").c_str(), pid, &_subface_offsets[0]);

    // Compute the natural coordinates.
    comp_nat_coors();
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void register_sdv_attributes ( const std::string &  wname ) const

protected

Definition at line 75 of file RFC_Window_base_IO.C.

References _b2v_table, _subface_counterparts, _subface_nat_coors, _subface_offsets, _subface_parents, _subfaces, _subnode_counterparts, _subnode_nat_coors, _subnode_normalized_nc, _subnode_parents, _subnode_subID, _v2b_table, COM_allocate_array(), COM_append_array(), COM_set_array_const(), COM_set_size(), COM_window_init_done(), get_point_of_subnode(), i, id(), iend, n, size_of_faces(), and size_of_subnodes().

                                                       {
  // Register the mesh
  const int pid = id();

  // Pack coordinates into double precision buffers
  int nnodes = size_of_subnodes();
  COM_set_size( (wname+".nc").c_str(), pid, nnodes);

  Point_3 *coor;
  COM_allocate_array( (wname+".nc").c_str(), pid, &(void*&)coor);
  for ( int i=0; i<nnodes; ++i)
    coor[i] = get_point_of_subnode( i+1);

  // Register subface connectivity, parents, and counterparts
  COM_set_size( (wname+".:t3").c_str(), pid, _subfaces.size());
  COM_set_array_const( (wname+".:t3").c_str(), pid, &_subfaces[0]);

  // Pack pane connectivity v2b of the pane into integer buffers 
  //      allocated in Roccom.
  int *v2b_buf;
  COM_set_size( (wname+".v2b").c_str(), pid, _v2b_table.size()*3);
  COM_allocate_array( (wname+".v2b").c_str(), pid, &(void*&)v2b_buf);

  for ( V2b_table::const_iterator
          it = _v2b_table.begin(), iend=_v2b_table.end(); it!=iend; ++it) {
    *(v2b_buf++) = it->first;
    *(v2b_buf++) = it->second.first;
    *(v2b_buf++) = it->second.second;
  }

  // Pack b2v into an integer buffer.
  std::string b2v_name=wname+".b2v";
  for ( B2v_table::const_iterator
          it=_b2v_table.begin(), iend=_b2v_table.end(); it != iend; ++it) {
    const B2v &b2v = it->second;
    int n=b2v.size();
    
    COM_append_array( b2v_name.c_str(), pid, &it->first, 0, 1);
    COM_append_array( b2v_name.c_str(), pid, &n, 0, 1);
    COM_append_array( b2v_name.c_str(), pid, &b2v[0], 0, b2v.size());
  }

  COM_set_array_const( (wname+".sn_parent_fcID").c_str(),
                       pid, &_subnode_parents[0].face_id, 2);
  COM_set_array_const( (wname+".sn_parent_ncs").c_str(), 
                       pid, &_subnode_normalized_nc[0], 2);

  // Permuted local coordinates within parent face
  COM_set_array_const( (wname+".sn_permu_edID").c_str(), 
                       pid, &_subnode_parents[0].edge_id, 2);
  COM_set_array_const( (wname+".sn_permu_ncs").c_str(), 
                       pid, &_subnode_nat_coors[0][0], 2);
  
  // Register the counterpart of each subnode
  COM_set_array_const( (wname+".sn_cntpt_pnID").c_str(), 
                       pid, &_subnode_counterparts[0].pane_id, 2);
  COM_set_array_const( (wname+".sn_cntpt_ndID").c_str(), 
                       pid, &_subnode_counterparts[0].node_id, 2);
  
  // Register the parent of each subface
  COM_set_array_const( (wname+".sf_parent").c_str(), 
                       pid, &_subface_parents[0]);

  // Register the natural coordinates of subnodes in each subface
  COM_set_array_const( (wname+".sf_ncs").c_str(), 
                       pid, &_subface_nat_coors[0]);

  // Register the counterpart in the other mesh of each subface
  COM_set_array_const( (wname+".sf_cntpt_pnID").c_str(), 
                       pid, &_subface_counterparts[0].pane_id, 2);
  COM_set_array_const( (wname+".sf_cntpt_fcID").c_str(), 
                       pid, &_subface_counterparts[0].face_id, 2);

  // Register the offset of the subface ID for each input facet
  COM_set_size( (wname+".sn_subID").c_str(), pid, _subnode_subID.size());
  COM_set_array_const( (wname+".sn_subID").c_str(), 
                       pid, &_subnode_subID[0]);
  
  // Register the offset of the subface ID for each input facet
  COM_set_size( (wname+".sf_offset").c_str(), pid, size_of_faces());
  COM_set_array_const( (wname+".sf_offset").c_str(), 
                       pid, &_subface_offsets[0]);
  
  COM_window_init_done( wname.c_str());
}

Here is the call graph for this function:

int size_of_border_nodes ( ) const

inline

Definition at line 234 of file RFC_Window_base.h.

References _n_border.

{ return _n_border; }

int size_of_faces ( ) const

inline

The total number of faces in the pane.

Definition at line 229 of file RFC_Window_base.h.

References _base.

Referenced by RFC_Pane_overlay::allocate_subfaces(), RFC_Pane_transfer::get_emm(), RFC_Window_transfer::init_facial_buffers(), RFC_Window_transfer::init_nodal_buffers(), Transfer_base::interpolate_fe(), Transfer_base::multiply_mass_mat_and_x(), RFC_Pane_transfer::need_recv(), read_binary(), read_rocin(), register_sdv_attributes(), RFC_Window_transfer::replicate_data(), and write_binary().

{ return _base->size_of_elements(); }

Here is the caller graph for this function:

int size_of_isolated_nodes ( ) const

inline

Definition at line 232 of file RFC_Window_base.h.

References _n_isolated.

Referenced by Transfer_base::interpolate_fe().

{ return _n_isolated; }

Here is the caller graph for this function:

int size_of_nodes ( ) const

inline

The total number of nodes in the pane.

Definition at line 227 of file RFC_Window_base.h.

References _base.

Referenced by RFC_Pane_overlay::build_hds(), comp_nat_coors(), get_bounding_box(), Transfer_base::interpolate_fe(), is_border_node(), is_isolated_node(), RFC_Window_overlay::print_features(), read_binary(), read_rocin(), RFC_Window_overlay::reduce_coordinates_to_all(), RFC_Window_transfer::replicate_data(), size_of_primary_nodes(), and write_binary().

{ return _base->size_of_nodes(); }

Here is the caller graph for this function:

int size_of_primary_nodes

(

)

const

Get total number of primary nodes contained in the pane.

Definition at line 210 of file RFC_Window_base.C.

References _v2b_table, iend, is_primary_node(), n, and size_of_nodes().

                                           {
  int n = size_of_nodes();
  for ( V2b_table::const_iterator it=_v2b_table.begin(), iend=_v2b_table.end();
        it != iend; ++it) {
    if ( !is_primary_node( it->first)) --n;
  }
  return n;
}

Here is the call graph for this function:

int size_of_subfaces ( ) const

inline

The total number of faces in the subdivision of the pane.

Definition at line 242 of file RFC_Window_base.h.

References _subfaces.

Referenced by comp_nat_coors(), RFC_Window_transfer::incident_faces(), RFC_Window_transfer::replicate_metadata(), and write_tec_sub().

{ return _subfaces.size(); }

Here is the caller graph for this function:

int size_of_subnodes ( ) const

inline

The total number of nodes in the subdivision of the pane.

Definition at line 240 of file RFC_Window_base.h.

References _subnode_parents.

Referenced by comp_nat_coors(), Transfer_base::interpolate_fe(), register_sdv_attributes(), and write_tec_sub().

{ return _subnode_parents.size(); }

Here is the caller graph for this function:

void write_binary ( std::ostream &  os ) const

protected

Definition at line 71 of file RFC_Window_base_IO_binary.C.

References _b2v_table, _base, _color, _subface_counterparts, _subface_offsets, _subface_parents, _subfaces, _subnode_counterparts, _subnode_nat_coors, _subnode_parents, _v2b_table, iend, n, RFC_assertion, size_of_faces(), size_of_nodes(), and write().

Referenced by RFC_Window_base::write_sdv().

                                    {
  RFC_assertion( sizeof(int)==4);
  RFC_assertion( sizeof(Real)==8);

  write( os, int(1));  // For detecting big or small endian
  Real  three = 3.;    // Version number (New version changed on 04/11/04)
  os.write( (char *)&three, sizeof(Real));

  // Write out color and the id of the pane.
  write( os, _color); write( os, id());
  
  // #nodes and #faces
  write( os, size_of_nodes()); write( os, size_of_faces());

  // Nodal coordinates of the pane
  const Real *p = _base->coordinates();
  os.write( (const char*)p, 3*_base->size_of_nodes()*sizeof(Real));

  if ( _base->is_structured()) {
    write( os, 1); 
    write( os, 2); write( os, 1); 
    write( os, _base->size_i()); write( os, _base->size_j()); 
  }
  else {
    std::vector< const COM::Connectivity*>  elems;
    _base->elements( elems);
    write( os, elems.size());
    // Output sizes of the faces
    for ( std::vector<const COM::Connectivity*>::const_iterator
            it = elems.begin(); it != elems.end(); ++it) {
      write( os, (*it)->size_of_nodes_pe()); 
      write( os, (*it)->size_of_elements());

      const int *e = (*it)->pointer();
      const int nn = (*it)->size_of_nodes_pe();
      os.write( (const char*)e, (*it)->size_of_elements()*nn*sizeof(int));
    }
  }

  // Pane connectivity of input mesh
  write( os, _b2v_table.size());
  for ( B2v_table::const_iterator 
          it=_b2v_table.begin(), iend=_b2v_table.end(); it != iend; ++it) {
    const B2v &b2v = it->second;

    int n=b2v.size();
    write( os, it->first); write( os, n);
    os.write( (const char*)&b2v[0], n*sizeof(b2v[0]));
  }
  write ( os, _v2b_table.size());
  for ( V2b_table::const_iterator
          it = _v2b_table.begin(), iend=_v2b_table.end(); it!=iend; ++it) {
    write( os, it->first); 
    write( os, it->second.first);
    write( os, it->second.second);
  }

  write(os, _subnode_parents.size()); write(os, _subfaces.size());

  // Output subnodes. 
  {
    int n=_subnode_parents.size(); 
    RFC_assertion( sizeof(_subnode_parents[0])==8);
    os.write( (const char*)&_subnode_parents[0], 
              n*sizeof(_subnode_parents[0]));
    os.write( (const char*)&_subnode_nat_coors[0], 
              n*sizeof(_subnode_nat_coors[0]));
    os.write( (const char*)&_subnode_counterparts[0], 
              n*sizeof(_subnode_counterparts[0]));
  }

  // Output subfaces.
  {
    int n = _subfaces.size();
    os.write( (const char*)&_subfaces[0], 
              n*sizeof(_subfaces[0]));
    os.write( (const char*)&_subface_parents[0], 
              n*sizeof(_subface_parents[0]));
    os.write( (const char*)&_subface_counterparts[0], 
              n*sizeof(_subface_counterparts[0]));
  }

  // Offsets of sub-faces.
  RFC_assertion( int(_subface_offsets.size()) == int(size_of_faces())+1);
  os.write( (const char*)&_subface_offsets[0],
            sizeof(int)*_subface_offsets.size());
  
  write( os, _subnode_parents.size()+_subfaces.size()); // Checksum
}

Here is the call graph for this function:

Here is the caller graph for this function:

RFC_BEGIN_NAME_SPACE void write_tec_ascii ( std::ostream &  os, const COM::Attribute *  attr = 0  ) const

protected

Definition at line 36 of file RFC_Window_base_IO_tecplot.C.

References _base, set_ascii_mode(), write_tec_ij(), write_tec_mixed(), and write_tec_tri().

Referenced by RFC_Window_base::write_tec_ascii().

                                                                 {
  if ( _base->size_of_nodes()==0) return;
  
  set_ascii_mode(os);
  if ( _base->is_structured()) 
    write_tec_ij( os, attr); // Structured mesh
  else { // Unstructured mesh
    std::vector< const COM::Connectivity*>  elems;
    _base->elements( elems);
    
    if ( elems.size() == 1 && elems[0]->size_of_edges_pe() == 3)
      // Triangular finite element mesh
      write_tec_tri( os, *elems[0], attr);
    else
      // Quadrilateral/mixed finite element mesh
      write_tec_mixed( os, elems, attr);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void write_tec_ij ( std::ostream &  os, const COM::Attribute *  a = 0  ) const

protected

Definition at line 83 of file RFC_Window_base_IO_tecplot.C.

References _base, i, n, RFC_assertion, and write_attr().

Referenced by write_tec_ascii().

                                                              {  
  RFC_assertion( _base != NULL);

  // Write out the head
  if ( attr)
    os << "TITLE = \"" << attr->name() << "\" \n";
  else
    os << "TITLE = \"Structured mesh\" \n";
  os << "VARIABLES = \"X\", \"Y\", \"Z\"";
  if ( attr) {
    const int MAXDIM=4, dim=attr->size_of_components();
    const char vname[MAXDIM+1]="UVWT";
    RFC_assertion( dim<=MAXDIM);
    for ( int i=0; i<dim; ++i)
      os << ", \"" << vname[i] << "\"";
  }
  os << "\nZONE I=" << _base->size_i()
     << ", J=" << _base->size_j() << ", F=POINT\n";

  // Write out the coordinates
  const Real *p = _base->coordinates();
  for ( int i=0, n=_base->size_of_nodes(); i<n; ++i) {
    os << p[3*i] << ' ' << p[3*i+1] << ' ' << p[3*i+2];
    if ( attr) write_attr( os, attr, i);
    os << std::endl; 
  }
  os << std::endl;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void write_tec_mixed ( std::ostream &  os, const std::vector< const COM::Connectivity * > &  elems, const COM::Attribute *  a = 0  ) const

protected

Definition at line 151 of file RFC_Window_base_IO_tecplot.C.

References _base, i, n, RFC_assertion, and write_attr().

Referenced by write_tec_ascii().

                                                 {
  RFC_assertion( _base != NULL);

  if ( attr)
    os << "TITLE = \"" << attr->name() << "\" \n";
  else
    os << "TITLE = \"Triangular finite element mesh\" \n";
  os << "VARIABLES = \"X\", \"Y\", \"Z\"";
  if ( attr) {
    const int MAXDIM=4, dim=attr->size_of_components();
    const char vname[MAXDIM+1]="UVWT";
    RFC_assertion( dim<=MAXDIM);
    for ( int i=0; i<dim; ++i)
      os << ", \"" << vname[i] << "\"";
  }
  os << "\nZONE N=" << _base->size_of_nodes() << ", E="
     << _base->size_of_elements() << ", F=FEPOINT, ET=QUADRILATERAL\n";

  // Write out the coordinates
  const Real *p = _base->coordinates();
  for ( int i=0, n=_base->size_of_nodes(); i<n; ++i) {
    os << p[3*i] << ' ' << p[3*i+1] << ' ' << p[3*i+2];
    if ( attr) write_attr( os, attr, i);
    os << std::endl;
  }
  os << std::endl;

  // Write out the elements
  for ( std::vector<const COM::Connectivity*>::const_iterator
          it = elems.begin(); it != elems.end(); ++it) {
    const int *e = (*it)->pointer();
    int nn = (*it)->size_of_nodes_pe();
    switch ( (*it)->size_of_edges_pe()) {
    case 3:
      for ( int i=0,n=(*it)->size_of_elements(); i<n; ++i)
      { os << e[nn*i] << ' ' << e[nn*i+1] << ' ' 
           << e[nn*i+2] << ' ' << e[nn*i+2] << std::endl; }
      break;
    case 4: 
      for ( int i=0, n=(*it)->size_of_elements(); i<n; ++i)
      { os << e[nn*i] << ' ' << e[nn*i+1] << ' ' 
           << e[nn*i+2] << ' ' << e[nn*i+3] << std::endl; }
      break;
    default:
      RFC_assertion( false);
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void write_tec_sub ( std::ostream &  os ) const

protected

Definition at line 205 of file RFC_Window_base_IO_tecplot.C.

References _base, _subfaces, get_point_of_subnode(), i, RFC_assertion, size_of_subfaces(), size_of_subnodes(), Point_3< T >::x(), Point_3< T >::y(), and Point_3< T >::z().

Referenced by RFC_Window_base::write_tec_sub().

                                     {
  RFC_assertion( _base != NULL);
  if ( size_of_subnodes() == 0) return;

  os << "TITLE = \"Triangular subdivision mesh\" \n";
  os << "VARIABLES = \"X\", \"Y\", \"Z\"";
  os << "\nZONE N=" << size_of_subnodes() << ", E="
     << size_of_subfaces() << ", F=FEPOINT, ET=TRIANGLE\n";

  // Write out the coordinates, and the node ids start from 1.
  for ( int i=1, size=size_of_subnodes(); i<=size; ++i) {
    Point_3 p = get_point_of_subnode( i);

    os << p.x() << ' ' << p.y() << ' ' << p.z() << std::endl;
  }
  os << std::endl;

  // Write out the elements. We directly access the connectivity table
  // and their indices start from 0. 
  for ( int i=0, size=size_of_subfaces(); i<size; ++i) {
    os << _subfaces[i][0] << ' ' << _subfaces[i][1] 
       << ' ' << _subfaces[i][2] << std::endl;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void write_tec_tri ( std::ostream &  os, const COM::Connectivity &  ec, const COM::Attribute *  a = 0  ) const

protected

Definition at line 114 of file RFC_Window_base_IO_tecplot.C.

References _base, i, n, RFC_assertion, and write_attr().

Referenced by write_tec_ascii().

                                               {  
  RFC_assertion( _base != NULL);

  if ( attr)
    os << "TITLE = \"" << attr->name() << "\" \n";
  else
    os << "TITLE = \"Triangular finite element mesh\" \n";
  os << "VARIABLES = \"X\", \"Y\", \"Z\"";
  if ( attr) {
    const int MAXDIM=4, dim=attr->size_of_components();
    const char vname[MAXDIM+1]="UVWT";
    RFC_assertion( dim<=MAXDIM);
    for ( int i=0; i<dim; ++i)
      os << ", \"" << vname[i] << "\"";
  }
  os << "\nZONE N=" << _base->size_of_nodes() << ", E="
     << _base->size_of_elements() << ", F=FEPOINT, ET=TRIANGLE\n";

  // Write out the coordinates
  const Real *p = _base->coordinates();
  for ( int i=0, n=_base->size_of_nodes(); i<n; ++i) {
    os << p[3*i] << ' ' << p[3*i+1] << ' ' << p[3*i+2];
    if ( attr) write_attr( os, attr, i);
    os << std::endl; 
  }
  os << std::endl;

  // Write out the elements
  const int *e = ec.pointer();
  int nn = ec.size_of_nodes_pe();
  for ( unsigned int i=0, n=_base->size_of_elements(); i<n; ++i)
  { os << e[nn*i] << ' ' << e[nn*i+1] << ' ' << e[nn*i+2] << std::endl; }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Friends And Related Function Documentation

friend class RFC_Window_base

friend

Definition at line 161 of file RFC_Window_base.h.

friend class RFC_Window_derived

friend

Definition at line 162 of file RFC_Window_base.h.

Member Data Documentation

B2v_table _b2v_table

protected

See Also

B2v_table

Definition at line 418 of file RFC_Window_base.h.

Referenced by build_v2b_from_b2v(), coincident(), RFC_Pane_overlay::determine_counterparts(), RFC_Window_base::export_window(), RFC_Window_derived< _Pane >::get_primary(), read_binary(), register_sdv_attributes(), and write_binary().

Base* _base

protected

Reference to its base object.

Definition at line 409 of file RFC_Window_base.h.

Referenced by base(), RFC_Pane_overlay::build_hds(), comp_nat_coors(), coordinates(), get_edge_id(), get_host_element_of_subface(), get_host_element_of_subnode(), get_nat_coor_in_element(), get_parent_node(), get_point(), get_point_of_subnode(), id(), init(), RFC_Window_transfer::init_nodal_buffers(), RFC_Pane_transfer::is_master(), pointer(), read_binary(), RFC_Window_transfer::set_tags(), size_of_faces(), size_of_nodes(), write_binary(), write_tec_ascii(), write_tec_ij(), write_tec_mixed(), write_tec_sub(), and write_tec_tri().

int _color

private

Is a node on border?

Definition at line 447 of file RFC_Window_base.h.

Referenced by color(), and write_binary().

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

private

Definition at line 449 of file RFC_Window_base.h.

Referenced by get_edge_id(), get_element(), and init().

std::vector< int> _elem_offsets

private

Definition at line 450 of file RFC_Window_base.h.

Referenced by get_element(), and init().

std::vector< bool> _is_border

protected

Is a node on border?

Definition at line 413 of file RFC_Window_base.h.

Referenced by init(), and is_border_node().

std::vector< bool> _is_isolated

protected

Is a node isolated?

Definition at line 414 of file RFC_Window_base.h.

Referenced by init(), and is_isolated_node().

bool _is_master

protected

Is the pane a master copy?

Definition at line 410 of file RFC_Window_base.h.

Referenced by is_master(), and is_replicate().

int _n_border

protected

Definition at line 415 of file RFC_Window_base.h.

Referenced by init(), and size_of_border_nodes().

int _n_isolated

protected

Definition at line 415 of file RFC_Window_base.h.

Referenced by init(), and size_of_isolated_nodes().

bool _quadratic

protected

Does it contain quadratic elements?

Definition at line 411 of file RFC_Window_base.h.

Referenced by RFC_Pane_overlay::build_hds(), init(), and is_quadratic().

std::vector< Face_ID> _subface_counterparts

protected

Ids of counterparts of faces.

Definition at line 440 of file RFC_Window_base.h.

Referenced by RFC_Pane_overlay::allocate_subfaces(), RFC_Window_base::export_window(), get_subface_counterpart(), RFC_Window_transfer::incident_faces(), RFC_Window_transfer::incident_panes(), RFC_Pane_overlay::insert_subface(), read_binary(), read_rocin(), register_sdv_attributes(), RFC_Window_transfer::replicate_metadata(), and write_binary().

std::vector< Three_tuple<Point_2S> > _subface_nat_coors

protected

Element connectivity of the subfaces.

Definition at line 444 of file RFC_Window_base.h.

Referenced by comp_nat_coors(), get_nat_coor_in_element(), read_rocin(), and register_sdv_attributes().

std::vector< int> _subface_offsets

protected

Offsets of first subfaces contained in a face.

Definition at line 438 of file RFC_Window_base.h.

Referenced by RFC_Pane_overlay::allocate_subfaces(), RFC_Window_base::export_window(), read_binary(), read_rocin(), register_sdv_attributes(), and write_binary().

std::vector< int > _subface_parents

protected

Face ids of the parents of the subfaces.

Definition at line 436 of file RFC_Window_base.h.

Referenced by RFC_Pane_overlay::allocate_subfaces(), comp_nat_coors(), RFC_Window_base::export_window(), get_host_element_of_subface(), get_parent_face(), RFC_Pane_overlay::insert_subface(), read_binary(), read_rocin(), register_sdv_attributes(), RFC_Window_transfer::replicate_metadata(), and write_binary().

std::vector< Three_tuple<int> > _subfaces

protected

Definition at line 434 of file RFC_Window_base.h.

Referenced by RFC_Pane_overlay::allocate_subfaces(), comp_nat_coors(), RFC_Window_base::export_window(), RFC_Pane_overlay::insert_subface(), read_binary(), read_rocin(), register_sdv_attributes(), RFC_Window_transfer::replicate_metadata(), size_of_subfaces(), write_binary(), and write_tec_sub().

std::vector< Node_ID> _subnode_counterparts

protected

Ids of counterparts of subnodes.

Definition at line 430 of file RFC_Window_base.h.

Referenced by RFC_Pane_overlay::allocate_subnodes(), RFC_Window_base::export_window(), get_subnode_counterpart(), RFC_Window_transfer::incident_panes(), RFC_Pane_overlay::insert_subface(), read_binary(), read_rocin(), register_sdv_attributes(), and write_binary().

std::vector< Point_2S> _subnode_nat_coors

protected

Natual coordinates in the parent face.

Definition at line 423 of file RFC_Window_base.h.

Referenced by RFC_Pane_overlay::allocate_subnodes(), RFC_Window_base::export_window(), get_nat_coor_in_element(), RFC_Pane_overlay::insert_subface(), parent_type_of_subnode(), read_binary(), read_rocin(), register_sdv_attributes(), and write_binary().

std::vector< Point_2S > _subnode_normalized_nc

protected

Natual coordinates in the parent face.

Definition at line 425 of file RFC_Window_base.h.

Referenced by comp_nat_coors(), get_host_element_of_subnode(), read_rocin(), and register_sdv_attributes().

std::vector< Edge_ID> _subnode_parents

protected

Edge ids of parents.

Definition at line 421 of file RFC_Window_base.h.

Referenced by RFC_Pane_overlay::allocate_subnodes(), comp_nat_coors(), RFC_Window_base::export_window(), get_host_element_of_subnode(), get_nat_coor_in_element(), get_parent_node(), get_point_of_subnode(), RFC_Pane_overlay::insert_subface(), read_binary(), read_rocin(), register_sdv_attributes(), RFC_Window_transfer::replicate_metadata(), size_of_subnodes(), and write_binary().

std::vector< int> _subnode_subID

protected

Sub-node ID of nodes in the pane.

Definition at line 427 of file RFC_Window_base.h.

Referenced by comp_nat_coors(), read_rocin(), and register_sdv_attributes().

V2b_table _v2b_table

protected

See Also

V2b_table

Definition at line 417 of file RFC_Window_base.h.

Referenced by build_v2b_from_b2v(), coincident(), RFC_Window_base::export_window(), RFC_Window_derived< _Pane >::get_primary(), is_primary_node(), read_binary(), read_rocin(), register_sdv_attributes(), size_of_primary_nodes(), and write_binary().

---

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

• RFC_Window_base.h
• RFC_Window_base.C
• RFC_Window_base_IO.C
• RFC_Window_base_IO_binary.C
• RFC_Window_base_IO_tecplot.C