Pane Class Reference

A Pane object contains a mesh, pane attribute, and field variables. More...

#include <Pane.h>

Inheritance diagram for Pane:

Collaboration diagram for Pane:

Classes
class	Attribute_friend
class	Connectivity_friend

Public Types
enum	OP_Init {   OP_SET =1, OP_SET_CONST, OP_ALLOC, OP_RESIZE,   OP_DEALLOC }
enum	Inherit_Modes { INHERIT_USE =0, INHERIT_CLONE, INHERIT_COPY }
typedef std::vector< Attribute * >	Attr_set
	Vector of attributs. More...
typedef std::vector < Connectivity * >	Cnct_set
	Vector of connectivities. More...
typedef unsigned int	Size
	Unsighed int. More...

Public Member Functions
Constructor and destructor
	Pane (Window *w, int i)
	Create a pane in window w with ID i. More...
	Pane (Pane *p, int i)
	Create a pane by copying from attribute descriptions from another pane. More...
virtual	~Pane ()
	Default destructor. More...
Initialization
void	init_done () throw (COM_exception)
	Finalize the initialization of a pane. More...
Identification
const Window *	window () const
	Obtain a constant pointer to its owner window object. More...
Window *	window ()
	Obtain a pointer to its owner window object. More...
int	id () const
	Get the ID of the pane. More...
int	dimension () const
	Dimension of the pane. More...
bool	is_unstructured () const
	Is mesh of the pane unstructured? More...
bool	is_mixed () const
	Does the pane contain more than one type of elements? More...
bool	is_structured () const
	Is mesh of the pane structured? More...
Mesh management
Size	size_of_nodes () const
	Get the total number of nodes in the pane (including ghost nodes). More...
Size	maxsize_of_nodes () const
	Get the maximum number of real nodes in the pane (excluding ghost nodes). More...
Size	size_of_ghost_nodes () const
	Get the number of ghost nodes. More...
Size	maxsize_of_ghost_nodes () const
	Get the maximum number of real nodes in the pane (excluding ghost nodes). More...
Size	size_of_real_nodes () const
	Get the number of real nodes in the pane (excluding ghost nodes). More...
Size	maxsize_of_real_nodes () const
	Get the maximum number of real nodes in the pane (excluding ghost nodes). More...
Size	size_of_elements () const
	Get the total number of elements in the pane (including ghost elements). More...
Size	maxsize_of_elements () const
	Get the maximum number of elements allowed in the pane (including ghost elements) More...
Size	size_of_ghost_elements () const
	Get the total number of ghost elements. More...
Size	maxsize_of_ghost_elements () const
	Get the maximum number of elements allowed in the pane (including ghost elements) More...
Size	size_of_real_elements () const
	Get the number of real elements in the pane (excluding ghost elements). More...
Size	maxsize_of_real_elements () const
	Get the maximum number of real elements allowed in the pane (excluding ghost elements). More...
double *	coordinates ()
	Get the pointer to the values of the coordinates. More...
double *	x_coordinates ()
	Get the pointer to the values of the x-coordinates, if the coordinates are staggered. More...
double *	y_coordinates ()
	Get the pointer to the values of the y-coordinates, if the coordinates are staggered. More...
double *	z_coordinates ()
	Get the pointer to the values of the z-coordinates, if the coordinates are staggered. More...
const double *	coordinates () const
	Get a constant pointer to the values of the coordinates. More...
const double *	x_coordinates () const
	Get a constant pointer to the values of the x-coordinates, if the coordinates are staggered. More...
const double *	y_coordinates () const
	Get a constant pointer to the values of the y-coordinates, if the coordinates are staggered. More...
const double *	z_coordinates () const
	Get a constant pointer to the values of the z-coordinates, if the coordinates are staggered. More...
int *	pane_connectivity ()
	Get a pointer to the values of the pane connectivity. More...
const int *	pane_connectivity () const
	Get a const pointer to the values of the pane connectivity. More...
bool	ignore_ghost () const
void	set_ignore_ghost (bool ignore)
Structured meshes
Size	size_of_ghost_layers () const
	Dimension of the pane. More...
Size	size_i () const
	Get the number of nodes in i-dimension if the mesh is structured. More...
Size	size_j () const
	Get the number of nodes in j-dimension if the mesh is structured. More...
Size	size_k () const
	Get the number of nodes in k-dimension if the mesh is structured. More...
Attribute management
void	attributes (std::vector< Attribute * > &as)
	Obtain all the attributes of the pane. More...
void	attributes (std::vector< const Attribute * > &as) const
	Obtain all the attributes of the pane. More...
Attribute *	attribute (const std::string &a)
	Obtain the attribute from given name. More...
const Attribute *	attribute (const std::string &a) const
	Obtain the attribute from given name. More...
Attribute *	attribute (int i)
	Obtain the attribute from its ID. More...
const Attribute *	attribute (int i) const
	Obtain the attribute from its ID. More...
Connectivity management
void	connectivities (std::vector< Connectivity * > &es)
	Obtain all the element connectivities of the pane. More...
void	connectivities (std::vector< const Connectivity * > &es) const
Connectivity *	connectivity (Size i) throw (COM_exception)
	Obtain the connectivity table containing the element with the given ID. More...
const Connectivity *	connectivity (Size i) const throw (COM_exception)
void	elements (std::vector< Connectivity * > &es)
	Obtain all the element connectivities of the pane. More...
void	elements (std::vector< const Connectivity * > &es) const
void	refresh_connectivity () throw (COM_exception)
	Update offsets and sizes of connectivity of an unstructured mesh. More...

Protected Member Functions
Attribute *	new_attribute (const std::string &aname, int aid, const char loc, const int type, int ncomp, const std::string &unit) throw (COM_exception)
void	insert (Attribute *attr) throw (COM_exception)
	Insert an attribute onto the pane. More...
void	delete_attribute (int id) throw (COM_exception)
	Delete an existing attribute with given id. More...
void	reinit_attr (int aid, OP_Init op, void **addr, int strd, int cap) throw (COM_exception)
const Connectivity *	connectivity (const std::string &a) const throw (COM_exception)
	Obtain the connectivity with the given name. More...
Connectivity *	connectivity (const std::string &a, bool insert=false) throw (COM_exception)
void	reinit_conn (Connectivity *con, OP_Init op, int **addr, int strd, int cap) throw (COM_exception)
Attribute *	inherit (Attribute *from, const std::string &aname, int mode, bool withghost) throw (COM_exception)
	Inherit an attribute from another pane onto the current pane: More...
void	set_size (Attribute *a, int nitems, int ng) throw ( COM_exception)
	Set the size of an attribute. More...
void	set_size (Connectivity *con, int nitems, int ng) throw ( COM_exception)
	Set the size of a connectivity table. More...

Protected Attributes
Window *	_window
	Point to the parent window. More...
int	_id
	Pane id. More...
Attr_set	_attr_set
	Set of attributes. More...
Cnct_set	_cnct_set
	Set of element connectivity. More...
bool	_ignore_ghost
	Whether the ghosts were ignored. More...

Private Member Functions
	Pane (const Pane &)
Pane &	operator= (const Pane &)

Detailed Description

A Pane object contains a mesh, pane attribute, and field variables.

Mesh data include nodal coordinates and element connectivity.

Definition at line 43 of file Pane.h.

Member Typedef Documentation

typedef std::vector<Attribute*> Attr_set

Vector of attributs.

Definition at line 45 of file Pane.h.

typedef std::vector<Connectivity*> Cnct_set

Vector of connectivities.

Definition at line 46 of file Pane.h.

typedef unsigned int Size

Unsighed int.

Definition at line 47 of file Pane.h.

Member Enumeration Documentation

enum Inherit_Modes

Enumerator
INHERIT_USE
INHERIT_CLONE
INHERIT_COPY

Definition at line 49 of file Pane.h.

{ INHERIT_USE=0, INHERIT_CLONE, INHERIT_COPY };

enum OP_Init

Enumerator
OP_SET
OP_SET_CONST
OP_ALLOC
OP_RESIZE
OP_DEALLOC

Definition at line 48 of file Pane.h.

{ OP_SET=1, OP_SET_CONST, OP_ALLOC, OP_RESIZE, OP_DEALLOC};

Constructor & Destructor Documentation

COM_BEGIN_NAME_SPACE Pane	(	Window *	w,
		int	i
	)

Create a pane in window w with ID i.

Definition at line 33 of file Pane.C.

References _attr_set, COM_NUM_KEYWORDS, and i.

                            :  
  _window(w), _id(i), _ignore_ghost(false) 
{
  _attr_set.resize( COM_NUM_KEYWORDS);
  Attribute *as = new Attribute[COM_NUM_KEYWORDS];

  for ( int i=0; i<COM_NUM_KEYWORDS; ++i) {
    // Call constructor in placement form.
    _attr_set[i] = new (&as[i]) Attribute_friend(this, i);
  }
}

Pane	(	Pane *	p,
		int	i
	)

Create a pane by copying from attribute descriptions from another pane.

Definition at line 45 of file Pane.C.

References _attr_set, COM_NUM_KEYWORDS, i, INHERIT_USE, Attribute::is_windowed(), k, n, nk, Attribute::pane(), and Attribute::size_of_components().

                           :
  _window(p->_window), _id(id), _ignore_ghost(false) 
{
  int n = p->_attr_set.size();
  _attr_set.resize( n, NULL);

  // First allocate for keywords
  Attribute *as = new Attribute[COM_NUM_KEYWORDS];
  for ( int i=0; i<COM_NUM_KEYWORDS; ++i) {
    _attr_set[i] = new (&as[i]) Attribute( this, p->_attr_set[i], "", i);
  }

  for ( int i=COM_NUM_KEYWORDS; i<n; ) {
    Attribute *ap=p->_attr_set[i];
    if ( ap==NULL || ap->pane()==NULL) { ++i; continue; }
    int ncomp=ap->size_of_components();

    // Allocate for attribute and its components
    as = new Attribute[ncomp+(ncomp>1)];

    // Call constructor at the attribute and its individual components
    for ( int k=0, nk=(ncomp==1)?0:ncomp; k<=nk; ++k,++i) 
      _attr_set[i] = new (&as[k]) Attribute( this, &ap[k], "", i);

    // Inherit window attributes from dummy pane
    if ( ap->is_windowed())
      reinterpret_cast<Attribute_friend*>(as)->inherit( ap, INHERIT_USE, true);
  }
}

Here is the call graph for this function:

~Pane ( )

virtual

Default destructor.

Definition at line 75 of file Pane.C.

References _attr_set, _cnct_set, COM_ATTS, delete_attribute(), i, and n.

            {
  delete [] _attr_set[0];  // Delete all keywords

  delete_attribute( COM_ATTS); // Delete all user-defined attributes.

  for ( Size i=0,n=_cnct_set.size(); i<n; ++i) 
    delete _cnct_set[i];  // Delete all connectivity tables.
}

Here is the call graph for this function:

Pane ( const Pane &  )

private

Member Function Documentation

Attribute * attribute

(

const std::string &

a

)

Obtain the attribute from given name.

Definition at line 148 of file Pane.C.

References _window, Window::attribute(), and Attribute::id().

Referenced by attribute(), Window::attribute(), Window::copy_array(), Window::get_array(), Window::get_parent(), Window::get_size(), Window::get_status(), Window::inherit(), inherit(), Attribute::maxsize_of_ghost_items(), Attribute::maxsize_of_items(), Attribute::maxsize_of_real_items(), Attribute::size_of_ghost_items(), Attribute::size_of_items(), Attribute::size_of_real_items(), Attribute::size_set(), Window::Window(), and write_attr_CGNS().

                               {
  Attribute *w_attr = _window->attribute(a);
  if ( w_attr==NULL) return NULL;

  return attribute( w_attr->id());
}

Here is the call graph for this function:

Here is the caller graph for this function:

const Attribute* attribute ( const std::string &  a ) const

inline

Obtain the attribute from given name.

Definition at line 239 of file Pane.h.

References attribute().

  { return const_cast<Pane*>(this)->attribute(a); }

Here is the call graph for this function:

Attribute * attribute

(

int

i

)

Obtain the attribute from its ID.

Definition at line 156 of file Pane.C.

References _attr_set, i, and Attribute::id().

                  {
  if ( (int)_attr_set.size() <= i) return NULL;
  Attribute *p_attr = _attr_set[ i];
  
  if ( p_attr==NULL || p_attr->id () != i) return NULL;
  return p_attr;
}

Here is the call graph for this function:

const Attribute* attribute ( int  i ) const

inline

Obtain the attribute from its ID.

Definition at line 246 of file Pane.h.

References attribute().

  { return const_cast<Pane*>(this)->attribute(i); }

Here is the call graph for this function:

void attributes

(

std::vector< Attribute * > &

as

)

Obtain all the attributes of the pane.

Definition at line 165 of file Pane.C.

References _attr_set, COM_NUM_KEYWORDS, i, Attribute::pane(), and Attribute::size_of_components().

Referenced by attributes(), Window::attributes(), and write_attr_CGNS().

                                                {
  as.reserve( _attr_set.size()-COM_NUM_KEYWORDS);
  for ( int i=COM_NUM_KEYWORDS, size=_attr_set.size(); i<size; ++i) {
    Attribute *a = _attr_set[i];
    if ( a==NULL || a->pane()==NULL) continue;

    as.push_back( a);
    int ncomp = a->size_of_components();
    if ( ncomp>1) i+=ncomp;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void attributes ( std::vector< const Attribute * > &  as ) const

inline

Obtain all the attributes of the pane.

Definition at line 233 of file Pane.h.

References attributes().

  { const_cast<Pane*>(this)->attributes((std::vector<Attribute*>&)as); }

Here is the call graph for this function:

void connectivities ( std::vector< Connectivity * > &  es )

inline

Obtain all the element connectivities of the pane.

Definition at line 254 of file Pane.h.

Referenced by connectivities(), and elements().

  { es = _cnct_set; }

Here is the caller graph for this function:

void connectivities ( std::vector< const Connectivity * > &  es ) const

inline

Definition at line 257 of file Pane.h.

References connectivities().

  { const_cast<Pane*>(this)->connectivities
      ( (std::vector<Connectivity*> &)es); }

Here is the call graph for this function:

Connectivity * connectivity	(	Size	i	)
throw	(	COM_exception
	)

Obtain the connectivity table containing the element with the given ID.

Definition at line 99 of file Pane.C.

References COM_assertion, COM_assertion_msg, i, Connectivity::index_offset(), and Connectivity::size_of_elements().

Referenced by connectivity(), Window::copy_array(), Window::get_array(), Window::get_parent(), Window::get_size(), Window::get_status(), Element_node_enumerator::next(), Element_node_enumerator_uns::next(), and Window::set_size().

{
  if ( i>size_of_elements()) {
    // if i is not a valid element ID, it must be one past the last ID
    COM_assertion( i-1==size_of_elements());
    return NULL;
  }

  // i must be either a valid element ID
  COM_assertion_msg( i>=1, "ElementID out of bounds");

  Cnct_set::iterator it=_cnct_set.begin();
  for ( ; it != _cnct_set.end(); ++it) {
    Connectivity *c=*it;
    if ( i>c->index_offset() && i<=c->index_offset()+c->size_of_elements()) 
      return c;
  }
  return NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

const Connectivity* connectivity ( Size  i ) const throw ( COM_exception )

inline

Definition at line 263 of file Pane.h.

References connectivity(), and i.

  { return const_cast<Pane*>(this)->connectivity( i); }

Here is the call graph for this function:

const Connectivity* connectivity ( const std::string &  a ) const throw ( COM_exception )

inlineprotected

Obtain the connectivity with the given name.

Definition at line 292 of file Pane.h.

References connectivity().

  { return const_cast<Pane*>(this)->connectivity( a); }

Here is the call graph for this function:

Connectivity * connectivity ( const std::string &  a, bool  insert = false  ) throw ( COM_exception )

protected

Definition at line 120 of file Pane.C.

References append_frame, COM_ERR_INVALID_ATTRIBUTE_NAME, COM_ERR_PANE_NOTEXIST, connectivity(), and Connectivity::get_size_info().

{
  if ( _id == 0) {
    throw COM_exception( COM_ERR_PANE_NOTEXIST, append_frame
                         (_window->name()+"."+a, Pane::connectivity));
  }
  Cnct_set::iterator it=_cnct_set.begin();
  for ( ; it != _cnct_set.end(); ++it) {
    if ( a==(*it)->name()) return *it;
  }
  if ( insert) {
    const int *size_info=Connectivity::get_size_info(a);
    if ( size_info) {
      Connectivity *c = new Connectivity(this, a, -1-int(_cnct_set.size()), 
                                         size_info);
      _cnct_set.push_back( c);
      return _cnct_set.back();
    }
    else
      throw COM_exception( COM_ERR_INVALID_ATTRIBUTE_NAME, append_frame
                           (_window->name()+"."+a, Pane::connectivity));
  }

  return NULL;
}

Here is the call graph for this function:

double* coordinates ( )

inline

Get the pointer to the values of the coordinates.

It returns NULL if the coordinates are staggered.

Definition at line 167 of file Pane.h.

References _attr_set, and COM_NC.

{ return (double *)_attr_set[COM_NC]->pointer(); }

const double* coordinates ( ) const

inline

Get a constant pointer to the values of the coordinates.

Definition at line 179 of file Pane.h.

References _attr_set, and COM_NC.

  { return (const double *)_attr_set[COM_NC]->pointer(); }

void delete_attribute ( int  id ) throw ( COM_exception )

protected

Delete an existing attribute with given id.

Definition at line 240 of file Pane.C.

References COM_assertion, COM_ATTS, COM_NUM_KEYWORDS, i, id(), n, Attribute::pane(), and Attribute::size_of_components().

Referenced by Window::delete_attribute(), and ~Pane().

                                                        {
  if ( id == COM_ATTS) { // Delete all user-defined attributes.
    for ( Size i=COM_NUM_KEYWORDS,n=_attr_set.size(); i<n; ++i) {
      Attribute *a=_attr_set[i];
      if ( a==NULL || a->pane()==NULL) continue;
      int ncomp = a->size_of_components();
      delete [] a; // Delete attribute and its individual components
      if (ncomp>1) i+=ncomp;
    }
    _attr_set.resize( COM_NUM_KEYWORDS);
  }
  else {
    Attribute *a = _attr_set[id]; COM_assertion(a);
    int ncomp = a->size_of_components();
    delete [] a; // Delete the attribute and its components.
    
    // Reset its pointers in _attr_set.
    for ( int i=id+((ncomp>1)?ncomp:0); i>=id; --i) _attr_set[i] = NULL;
    
    if ( id+ncomp+(ncomp>1) ==int(_attr_set.size())) 
      _attr_set.resize( id);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

int dimension ( ) const

inline

Dimension of the pane.

Definition at line 99 of file Pane.h.

References _cnct_set.

Referenced by Pane_node_enumerator::dimension(), Element_node_enumerator::dimension(), Element_node_enumerator::Element_node_enumerator(), Pane_node_enumerator::next(), Element_node_enumerator::next(), Pane_node_enumerator::Pane_node_enumerator(), Element_node_enumerator::size_of_corners(), Element_node_enumerator::size_of_edges(), Element_node_enumerator::size_of_faces(), Element_node_enumerator::size_of_nodes(), Element_node_enumerator::type(), and write_attr_CGNS().

  { return _cnct_set.empty()?0:_cnct_set[0]->dimension(); }

Here is the caller graph for this function:

void elements ( std::vector< Connectivity * > &  es )

inline

Obtain all the element connectivities of the pane.

Kept for backward compatibility

Definition at line 268 of file Pane.h.

References connectivities().

Referenced by write_attr_CGNS().

{ connectivities(es); }

Here is the call graph for this function:

Here is the caller graph for this function:

void elements ( std::vector< const Connectivity * > &  es ) const

inline

Definition at line 269 of file Pane.h.

References connectivities().

  { connectivities(es); }

Here is the call graph for this function:

int id ( ) const

inline

Get the ID of the pane.

Definition at line 96 of file Pane.h.

References _id.

Referenced by Rocblas::gen2arg(), Window::inherit(), Window::reinit_attr(), Window::reinit_conn(), Element_node_vectors_k_const< Value >::set(), Element_vectors_k_const< Value >::set(), and write_attr_CGNS().

{ return _id; }

Here is the caller graph for this function:

bool ignore_ghost ( ) const

inline

Definition at line 202 of file Pane.h.

References _ignore_ghost.

Referenced by Attribute::maxsize_of_ghost_items(), Attribute::maxsize_of_items(), Connectivity::size_of_elements(), Attribute::size_of_ghost_items(), Attribute::size_of_items(), and Connectivity::size_of_nodes().

{ return _ignore_ghost; }

Here is the caller graph for this function:

Attribute * inherit ( Attribute *  from, const std::string &  aname, int  mode, bool  withghost  ) throw ( COM_exception )

protected

Inherit an attribute from another pane onto the current pane:

Definition at line 451 of file Pane.C.

References append_frame, attribute(), CATCHBADALLOC_APPEND, CATCHEXP_APPEND, COM_ALL, COM_assertion, COM_assertion_msg, COM_ATTS, COM_CONN, COM_ERR_ATTRIBUTE_NOTEXIST, COM_ERR_GHOST_LAYERS, COM_ERR_INCOMPATIBLE_TYPES, COM_MESH, COM_NC, COM_NUM_KEYWORDS, COM_PCONN, COM_PMESH, COM_RIDGES, Attribute::compatible_types(), Attribute::copy_array(), Attribute::data_type(), Attribute::fullname(), i, Attribute::id(), iend, Attribute::inherit(), Attribute::is_windowed(), j, Attribute::location(), n, ni, nj, Attribute::pane(), Attribute::pointer(), Connectivity::pointer(), Attribute::size_of_components(), Attribute::size_of_items(), Attribute::size_of_real_items(), and Attribute::stride().

Referenced by Window::inherit().

{
  if ( from==NULL) 
    throw COM_exception( COM_ERR_ATTRIBUTE_NOTEXIST, append_frame
                         (_window->name()+"."+aname,Pane::inherit));

  switch (from->id()) { // Process keywords
  case COM_ALL:
    inherit( from->pane()->attribute( COM_PMESH), "", mode, withghost);
    inherit( from->pane()->attribute( COM_ATTS), "", mode, withghost);
    return attribute( COM_ALL);
  case COM_MESH:
    inherit( from->pane()->attribute( COM_NC), "", mode, withghost);
    inherit( from->pane()->attribute( COM_CONN), "", mode, withghost);
    inherit( from->pane()->attribute( COM_RIDGES), "", mode, withghost);
    return attribute( COM_MESH);
  case COM_PMESH:
    inherit( from->pane()->attribute( COM_NC), "", mode, withghost);
    inherit( from->pane()->attribute( COM_CONN), "", mode, withghost);
    inherit( from->pane()->attribute( COM_RIDGES), "", mode, withghost);
    inherit( from->pane()->attribute( COM_PCONN), "", mode, withghost);
    return attribute( COM_PMESH);
  case COM_ATTS: {
    // Loop through all attributes
    std::vector<Attribute*> &atts=from->pane()->_attr_set;
    
    for ( int i=COM_NUM_KEYWORDS,n=atts.size(); i<n; ++i) {
      Attribute *a = atts[i];
      if ( a==NULL || a->pane()==NULL) continue;
      if ( !a->is_windowed() || _id==0)
        inherit( a, "", mode, withghost);
      int ncomp= a->size_of_components();
      if ( ncomp>1) i+= ncomp;
    }
    return attribute( COM_ATTS);
  }
  case COM_CONN: {
    if ( _id==0) return attribute(COM_CONN);

    if (mode != INHERIT_COPY) {
      // Clean up the current connectivity tables
      for ( Size i=0; i<_cnct_set.size(); ++i) delete _cnct_set[i]; 
      _cnct_set.clear();
      
      if ( mode==INHERIT_USE) {
        ((Attribute_friend*)_attr_set[COM_CONN])->inherit( from, false, withghost);
        // Check that if structured meshes, the nodal coordinates 
        // was also used.
        COM_assertion( !is_structured() || _attr_set[COM_NC]->parent() && 
                       _attr_set[COM_NC]->parent()->pane() == from->pane());
      }

      // Inherit individual connectivity tables
      std::vector<Connectivity*>::iterator it=from->pane()->_cnct_set.begin();
      std::vector<Connectivity*>::iterator iend=from->pane()->_cnct_set.end();
      for ( ; it != iend; ++it) {
        _cnct_set.push_back( new Connectivity( this, *it, (*it)->name(),
                                               -_cnct_set.size()-1));
        ((Connectivity_friend*)_cnct_set.back())->inherit(*it, mode, withghost);
      }

      // Set _ignore_ghost
      _ignore_ghost = !withghost;
      if ( _ignore_ghost && is_structured() && size_of_ghost_layers())
        throw COM_exception(COM_ERR_GHOST_LAYERS, append_frame
                            (_window->name()+"."+aname,Pane::inherit));
    
      if ( mode == INHERIT_USE) return attribute( COM_ATTS);
    }

    // Continue to copy mode
    // Do not copy connectivity tables for structured meshes.
    const std::vector<Connectivity*> &es = from->pane()->_cnct_set;
    COM_assertion_msg( es.size() == _cnct_set.size(),
                       "Number of connectivity tables do not match");
      
    // Loop over the connectivity tables to copy each table
    for ( int i=0, ni=_cnct_set.size(); i<ni; ++i) {
      const Connectivity *conn=es[i];
      int n=withghost?conn->size_of_items():conn->size_of_real_items();
      _cnct_set[i]->copy_array( const_cast<int*>(conn->pointer()), 
                                conn->stride(), n);
    }

    refresh_connectivity();
    return attribute( COM_ATTS);
  }
  default: ;
  }

  std::string str = aname.size()?aname:from->name();

  // If from is a keyword and target is the same, then the current 
  // attribute must have the same ID. Otherwise, must find from name.
  Attribute *a=(from->id()<COM_NUM_KEYWORDS && aname.empty())?
    attribute(from->id()) : _window->attribute(str);

  if ( mode != INHERIT_COPY) {
    if ( _id == 0) {
      if ( a==NULL || a->size_of_components()!=from->size_of_components()) { 
        // New attribute only if it does not exist or the sizes do not match
        try {
          a=_window->new_attribute( str, from->location(), from->data_type(),
                                    from->size_of_components(), from->unit());

          if ( from->is_windowed())
            ((Attribute_friend*)a)->inherit( from, mode, withghost);

        } CATCHEXP_APPEND(Pane::inherit);
      }
      else try {
        ((Attribute_friend*)a)->inherit( from, mode, withghost);
      } CATCHEXP_APPEND(Pane::inherit) CATCHBADALLOC_APPEND(Pane::inherit);

      if ( mode == INHERIT_USE || !from->is_windowed()) return a;
    }
    else {
      COM_assertion( a);
      a = _attr_set[a->id()]; 
      try { 
        ((Attribute_friend*)a)->inherit( from, mode, withghost);
      } CATCHEXP_APPEND(Pane::inherit) CATCHBADALLOC_APPEND(Pane::inherit);
      
      if ( mode == INHERIT_USE) return a;
    }
  }
  else {
    // Copy an attribute only if it exists in the target window.
    if ( a) a = _attr_set[a->id()];
    else return a;

    if ( !Attribute::compatible_types( from->data_type(), a->data_type()))
      throw COM_exception( COM_ERR_INCOMPATIBLE_TYPES, append_frame
                           (from->fullname()+" and "+a->fullname(),
                            Pane::inherit));
  }

  if ( (_id==0) != (from->is_windowed())) return a;

  // Continue to copy dataset
  if ( !withghost && is_structured() && size_of_ghost_layers())
    throw COM_exception(COM_ERR_GHOST_LAYERS, append_frame
                        (_window->name()+"."+aname,Pane::inherit));
    
  // count is the number of panes, nodes, or elements to loop through
  int count = withghost?from->size_of_items():from->size_of_real_items();
  int s_nc = from->size_of_components();
  const Pane *src_pane = from->pane();

  COM_assertion_msg( from->location() == a->location(),
                     (std::string("Location of attributes ")+
                      from->fullname()+" and " +a->fullname()+ 
                      " do not match during copying.").c_str());

  // loop through components of source's data
  if ( count) for ( int j=(s_nc>1), nj=s_nc-(s_nc==1); j<=nj; ++j) {
    // src_data points to source data for current component
    const Attribute *src_data = src_pane->attribute( from->id()+j);
      
    // dest_data points to dest data for current component
    Attribute *dest_data = attribute( a->id()+j);
    
    if ( dest_data->pointer() && src_data->pointer()) {
      COM_assertion_msg( withghost && dest_data->size_of_items()==src_data->size_of_items() ||  
                         !withghost && dest_data->size_of_real_items()==src_data->size_of_real_items(),
                         (std::string("Number of items of attributes ")+
                          from->fullname()+" and " +a->fullname()+ 
                          " do not match during copying.").c_str());
      try {
        dest_data->copy_array( const_cast<void*>(src_data->pointer()), 
                               src_data->stride(), count);
      } CATCHEXP_APPEND(Pane::inherit);
    }
  }

  return a;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void init_done	(		)
throw	(	COM_exception
	)

Finalize the initialization of a pane.

Definition at line 85 of file Pane.C.

References _attr_set, _window, append_frame, Attribute::capacity(), COM_ERR_INVALID_CAPACITY, Attribute::fullname(), i, Attribute::initialized(), Window::last_attribute_id(), Attribute::pane(), s, and Attribute::size_of_items().

                                          {
  _attr_set.resize( _window->last_attribute_id()); // Shrink the array.

  // Loop through the attributes to initialize the unitialized ones to NULL
  for ( int i=0, s=_attr_set.size(); i<s; ++i) {
    Attribute *a = _attr_set[i];
    if ( a==NULL || a->pane()==NULL) continue;

    if ( a->initialized() && a->size_of_items()>a->capacity()) 
      throw COM_exception( COM_ERR_INVALID_CAPACITY, 
                           append_frame(a->fullname(), Pane::init_done));
  }
}

Here is the call graph for this function:

void insert ( Attribute *  attr ) throw ( COM_exception )

protected

Insert an attribute onto the pane.

Definition at line 224 of file Pane.C.

References COM_assertion, id(), and s.

Referenced by rflu_modrepair3d::putpnt(), and rflu_modrepair3d::volput().

                                                       {
  COM_assertion( attr->pane()==this);

  // Determine id of the new attribute
  int id = attr->id();

  // Resize _attr_set and delete existing attribute with the id
  if ( int(_attr_set.size())<=id) { // resize _attr_set
    int s = attr->size_of_components();
    _attr_set.resize( id+s+(s>1), NULL);
  }

  if ( _attr_set[id]==NULL) _attr_set[id] = attr;
  else COM_assertion( attr == _attr_set[id]);
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool is_mixed ( ) const

inline

Does the pane contain more than one type of elements?

Definition at line 107 of file Pane.h.

References _cnct_set.

{ return _cnct_set.size()>1; }

bool is_structured ( ) const

inline

Is mesh of the pane structured?

Definition at line 110 of file Pane.h.

References _cnct_set.

Referenced by Element_node_enumerator::Element_node_enumerator(), Element_node_enumerator::id(), refresh_connectivity(), size_i(), size_j(), size_k(), Element_node_enumerator::vertex(), and write_attr_CGNS().

  { return _cnct_set.size()==1 && _cnct_set[0]->is_structured(); }

Here is the caller graph for this function:

bool is_unstructured ( ) const

inline

Is mesh of the pane unstructured?

Definition at line 103 of file Pane.h.

References _cnct_set.

Referenced by Element_node_enumerator::Element_node_enumerator(), Pane_node_enumerator::next(), Pane_node_enumerator::Pane_node_enumerator(), and write_attr_CGNS().

  { return _cnct_set.size()!=1 || !_cnct_set[0]->is_structured(); }

Here is the caller graph for this function:

Size maxsize_of_elements ( ) const

inline

Get the maximum number of elements allowed in the pane (including ghost elements)

Definition at line 146 of file Pane.h.

References _attr_set, and COM_CONN.

  { return _attr_set[COM_CONN]->maxsize_of_items(); }

Size maxsize_of_ghost_elements ( ) const

inline

Get the maximum number of elements allowed in the pane (including ghost elements)

Definition at line 154 of file Pane.h.

References _attr_set, and COM_CONN.

  { return _attr_set[COM_CONN]->maxsize_of_ghost_items(); }

Size maxsize_of_ghost_nodes ( ) const

inline

Get the maximum number of real nodes in the pane (excluding ghost nodes).

Definition at line 130 of file Pane.h.

References _attr_set, and COM_NC.

  { return _attr_set[COM_NC]->maxsize_of_ghost_items(); }

Size maxsize_of_nodes ( ) const

inline

Get the maximum number of real nodes in the pane (excluding ghost nodes).

Definition at line 122 of file Pane.h.

References _attr_set, and COM_NC.

  { return _attr_set[COM_NC]->maxsize_of_items(); }

Size maxsize_of_real_elements ( ) const

inline

Get the maximum number of real elements allowed in the pane (excluding ghost elements).

Definition at line 162 of file Pane.h.

References _attr_set, and COM_CONN.

  { return _attr_set[COM_CONN]->maxsize_of_real_items(); }

Size maxsize_of_real_nodes ( ) const

inline

Get the maximum number of real nodes in the pane (excluding ghost nodes).

Definition at line 138 of file Pane.h.

References _attr_set, and COM_NC.

  { return _attr_set[COM_NC]->maxsize_of_real_items(); }

Attribute * new_attribute ( const std::string &  aname, int  aid, const char  loc, const int  type, int  ncomp, const std::string &  unit  ) throw ( COM_exception )

protected

Definition at line 178 of file Pane.C.

References append_frame, COM_assertion, COM_ERR_INVALID_ATTRIBUTE_NAME, i, n, and Attribute::name().

Referenced by Window::new_attribute().

{

  if ( loc == 'c' && id() != 0) {
    // check if connectivity table exists, make sure it is not dummy pane
    std::string::size_type pos = aname.find( ":");
    std::string conn = aname.substr(pos, aname.size());
    Connectivity *con = connectivity( conn,false);
    if (con == NULL)
      throw COM_exception( COM_ERR_INVALID_ATTRIBUTE_NAME, 
                         append_frame(aname, Pane::new_attribute));
  }

  // Insert the object into both the set and the map.
  Attribute *atts;
  if ( aid>=int(_attr_set.size()))
    atts = new Attribute[ncomp+(ncomp>1)]; // Allocate memory
  else {
    atts = attribute(aid); COM_assertion( atts);
    // Call destructors
    for ( int i=0, n=ncomp+(ncomp>1); i<n; ++i) atts[i].~Attribute();
  }
  Attribute *a = new (atts) Attribute( this, aname, aid, loc, 
                                       type, ncomp, unit);
  insert( a);
  
  // Create an object for each individual component
  if ( ncomp>1) for ( int i=1; i<=ncomp; ++i) {
    char buf[10];
    std::sprintf( buf, "%d-", i);
    std::string newname = std::string( buf)+a->name();
    
    Attribute *ai = new (&atts[i]) Attribute( this, newname, aid+i, 
                                              loc,  type, 1, unit);
    insert( ai);
  }

  if ( _id && loc == 'w') { // Inherit window attribute
    reinterpret_cast<Attribute_friend*>(a)->
      inherit( _window->attribute( aid), INHERIT_USE, true);
  }
  return a;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Pane& operator= ( const Pane &  )

private

int* pane_connectivity ( )

inline

Get a pointer to the values of the pane connectivity.

Definition at line 195 of file Pane.h.

References _attr_set, and COM_PCONN.

  { return (int*)_attr_set[COM_PCONN]->pointer(); }

const int* pane_connectivity ( ) const

inline

Get a const pointer to the values of the pane connectivity.

Definition at line 199 of file Pane.h.

References _attr_set, and COM_PCONN.

  { return (const int *)_attr_set[COM_PCONN]->pointer(); }

void refresh_connectivity	(		)
throw	(	COM_exception
	)

Update offsets and sizes of connectivity of an unstructured mesh.

Definition at line 667 of file Pane.C.

References _attr_set, _cnct_set, _window, append_frame, COM_CONN, COM_ERR_INVALID_SIZE, COM_NC, is_structured(), Window::name(), Connectivity::set_offset(), Connectivity::size_of_elements(), Connectivity::size_of_ghost_elements(), size_of_ghost_nodes(), and size_of_nodes().

                                                     {
  int nelems = 0, ngelems = 0;

  // Set the number of elements
  if ( !_attr_set[COM_CONN]->parent()) {
    // Loop through the connectivity table
    Cnct_set::iterator it=_cnct_set.begin();
    for ( ; it != _cnct_set.end(); ++it) {
      Connectivity_friend *con = (Connectivity_friend*)*it;
      con->set_offset( nelems);
      nelems += con->size_of_elements();
      ngelems += con->size_of_ghost_elements();
    }

    if ( nelems<0 || ngelems<0)
      throw COM_exception( COM_ERR_INVALID_SIZE, append_frame
                           ( _window->name(), Pane::refresh_connectivity));
    _attr_set[COM_CONN]->set_size(nelems, ngelems);
  }

  // Set the number of nodes for structured meshes
  if ( is_structured() && !_attr_set[COM_NC]->parent()) {
    _attr_set[COM_NC]->set_size(_cnct_set[0]->size_of_nodes(), 
                                _cnct_set[0]->size_of_ghost_nodes());
  }
}

Here is the call graph for this function:

void reinit_attr ( int  aid, OP_Init  op, void **  addr, int  strd, int  cap  ) throw ( COM_exception )

protected

Definition at line 265 of file Pane.C.

References Attribute::allocate(), append_frame, Attribute::capacity(), COM_ALL, COM_assertion, COM_ATTS, COM_CONN, COM_ERR_ATTRIBUTE_NOTEXIST, COM_ERR_INVALID_SIZE, COM_ERR_PANE_NOTEXIST, COM_ERR_WAS_INITIALIZED, COM_MESH, COM_NC, COM_NUM_KEYWORDS, COM_PCONN, COM_PMESH, COM_RIDGES, Attribute::deallocate(), Attribute::fullname(), i, Attribute::is_digit(), Attribute::is_windowed(), n, Attribute::name(), Attribute::pane(), Attribute::set_size(), Attribute::size_of_components(), Attribute::size_of_items(), Attribute::size_set(), and Attribute::stride().

Referenced by Window::reinit_attr().

{
  switch ( aid) {
  case COM_CONN: {
    COM_assertion( op != OP_SET && op != OP_SET_CONST);
    // loop through the connectivity
    for ( int i=0, n=_cnct_set.size(); i<n; ++i) {
      if ( !_cnct_set[i]->is_structured())
        reinit_conn( _cnct_set[i], op, NULL, strd, cap);
    }

    if ( addr) *addr = NULL;
    return;
  }
  case COM_MESH: {
    COM_assertion( op != OP_SET && op != OP_SET_CONST);
    reinit_attr( COM_NC, op, NULL, strd, cap);
    reinit_attr( COM_CONN, op, NULL, strd, cap);
    reinit_attr( COM_RIDGES, op, NULL, strd, cap);
    if ( addr) *addr = NULL;
    return;
  }
  case COM_PMESH: {
    COM_assertion( op != OP_SET && op != OP_SET_CONST);
    reinit_attr( COM_NC, op, NULL, strd, cap);
    reinit_attr( COM_CONN, op, NULL, strd, cap);
    reinit_attr( COM_RIDGES, op, NULL, strd, cap);
    reinit_attr( COM_PCONN, op, NULL, strd, cap);
    if ( addr) *addr = NULL;
    return;
  }
  case COM_ATTS: {
    COM_assertion( op != OP_SET && op != OP_SET_CONST);
    // Loop through the attributes
    for ( int i=COM_NUM_KEYWORDS, n=_attr_set.size(); i<n; ++i) {
      Attribute *a = _attr_set[i];
      if ( a==NULL || a->pane()==NULL) continue;
      if ( !a->is_windowed() || _id==0)
        reinit_attr( i, op, NULL, strd, cap);
      int ncomp= a->size_of_components();
      if ( ncomp>1) i+= ncomp;
    }
    return;
  }
  case COM_ALL: {
    COM_assertion( op != OP_SET && op != OP_SET_CONST);
    reinit_attr( COM_PMESH, op, NULL, strd, cap);
    reinit_attr( COM_ATTS, op, NULL, strd, cap);
    return;
  }
  default: ;
  }

  Attribute *a = attribute( aid);
  if ( a==NULL) 
    throw COM_exception( COM_ERR_ATTRIBUTE_NOTEXIST, 
                         append_frame(a->fullname(), Pane::reinit_attr));

  // If _id is 0, then handle only window attributes.
  if ( !a->is_windowed() && !_id) {
    if (op == OP_SET || op == OP_SET_CONST)
      throw COM_exception( COM_ERR_PANE_NOTEXIST, append_frame
                           ( _window->name(), Pane::reinit_attr));
    else
      return;
  }

  int errcode;
  void *p;
  int ncomp = a->size_of_components();
      
  if ( op==OP_DEALLOC) {
    // Deallocate if was allocated by Roccom
    errcode = a->deallocate(); 
    p = NULL;
  }
  else {
    COM_assertion( op==OP_SET_CONST||op==OP_SET||op==OP_ALLOC||op==OP_RESIZE);

    // If size is not yet set
    if ( !a->size_set()) {
      if ( a->is_windowed())
        a->set_size(1);  // Change the default size of window attributes to 1
      else // Throw an exception for other types of attributes
        throw COM_exception( COM_ERR_INVALID_SIZE, 
                             append_frame(a->fullname(), Pane::reinit_attr));
    }

    // Assign default value for cap and strd
    if ( cap==0) {
      // Default value for capacity is the number of items for set_array
      // but the large of the current capacity and the the number of items.
      if ( op==OP_SET || op==OP_SET_CONST) cap = a->size_of_items();
      else {
        if ( a->capacity()==0)
          cap = a->size_of_items();
        else if ( a->size_of_items()<=a->capacity())
          cap = a->capacity();
        else 
          cap = a->size_of_items()+a->size_of_items()/5;  // Current size pluse 20% more
      }
    }

    if ( (op == OP_SET || op == OP_SET_CONST) && *addr && cap==0)
      *addr = NULL; // Enforce the array to be a NULL pointer

    // Make the attribute itself set to NULL if operating on its components.
    if ( Attribute::is_digit(a->name()[0])) {
      int icomp=std::atoi( a->name().c_str());
      if ( attribute(aid-icomp)->initialized())
        throw COM_exception(COM_ERR_WAS_INITIALIZED, 
                            append_frame(a->fullname(), Pane::reinit_attr));
    }

    if ( strd==0 || strd<0 && a->stride()==0) 
      // Default value for stride is number of components
      strd = ncomp;
    else if ( strd<0)
      strd = a->stride();

    if ( op == OP_SET || op == OP_SET_CONST) {
      ((Attribute_friend*)a)->set_pointer(*addr, strd, cap, 
                                          0, op==OP_SET_CONST);
      p = *addr;
    }
    else {
      p = a->allocate( strd, cap, op == OP_ALLOC);
      if ( addr) *addr = p;
    }
    errcode=0;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void reinit_conn ( Connectivity *  con, OP_Init  op, int **  addr, int  strd, int  cap  ) throw ( COM_exception )

protected

Definition at line 400 of file Pane.C.

References append_frame, COM_ERR_ALLOC_STRUCTURED, and COM_ERR_PANE_NOTEXIST.

{
  // Assign default value for cap and strd
  if ( op!=OP_DEALLOC) {
    if ( cap==0) {
      // Default value for capacity is the number of items for set_array
      // but the large of the current capacity and the the number of items plus some buffer.
      if ( op==OP_SET || op==OP_SET_CONST) cap = con->size_of_items();
      else {
        if ( con->capacity()==0)
          cap = con->size_of_items();
        else if ( con->size_of_items()<=con->capacity())
          cap = con->capacity();
        else 
          cap = con->size_of_items()+con->size_of_items()/5;  // Current size pluse 20% more
      }
    }

    if ( strd==0 || strd<0 && con->stride()==0) 
      // Default value for stride is number of components
      strd = con->size_of_components();
    else if ( strd<0)
      strd = con->stride();
  }

  if ( op == OP_SET || op == OP_SET_CONST) {
    if ( !id()) 
      throw COM_exception( COM_ERR_PANE_NOTEXIST, 
                           append_frame(con->fullname(),Pane::reinit_conn));

    if ( *addr && cap==0 && !con->is_structured())
      *addr = NULL; // Enforce the array to be a NULL pointer

    ((Connectivity_friend*)con)->set_pointer( *addr, strd, cap,
                                              op==OP_SET_CONST);
  }
  else {
    if ( con->is_structured()) 
      throw COM_exception( COM_ERR_ALLOC_STRUCTURED, 
                           append_frame(con->fullname(),Pane::reinit_conn));
    void *p=NULL;
    if ( op==OP_DEALLOC) 
    { con->deallocate(); p=NULL; }
    else 
      p = con->allocate( strd, cap, op==OP_ALLOC);
    
    if ( addr) *addr = (int*)p;
  }
}

void set_ignore_ghost ( bool  ignore )

inline

Definition at line 204 of file Pane.h.

References _ignore_ghost.

{ _ignore_ghost = ignore; }

void set_size ( Attribute *  a, int  nitems, int  ng  ) throw ( COM_exception )

protected

Set the size of an attribute.

Definition at line 630 of file Pane.C.

References append_frame, COM_assertion_msg, COM_CONN, COM_ERR_INVALID_SIZE, COM_ERR_PANE_NOTEXIST, and COM_NC.

Referenced by Window::set_size(), and set_size().

                                                               {
  if ( nitems<ng)
    throw COM_exception( COM_ERR_INVALID_SIZE, 
                         append_frame(a->fullname(),Pane::set_size));
  // Get the corresponding attribute object.
  if ( !a->is_windowed() && !_id) 
    throw COM_exception(COM_ERR_PANE_NOTEXIST,
                        append_frame(a->fullname(),Pane::set_size));

  if ( a->is_nodal()) {
    COM_assertion_msg( a->id() == COM_NC, 
                       (std::string("Cannot set size for nodal attribute ")+
                        a->fullname()+". Must use the nc attribute").c_str());

    _attr_set[COM_NC]->set_size( nitems, ng);
  }
  else if ( a->is_elemental()) {
    COM_assertion_msg( a->id() == COM_CONN, 
                       (std::string("Cannot set size for elemental attribute ")+
                        a->fullname()+". Must use the conn attribute").c_str());
    
    _attr_set[COM_CONN]->set_size( nitems, ng);
  }
  else {
    attribute(a->id())->set_size( nitems, ng);
  }
}

Here is the caller graph for this function:

void set_size ( Connectivity *  con, int  nitems, int  ng  ) throw ( COM_exception )

protected

Set the size of a connectivity table.

Definition at line 659 of file Pane.C.

References append_frame, COM_ERR_INVALID_SIZE, and set_size().

                                                               {
  if ( !con->is_structured() && nitems<ng)
    throw COM_exception( COM_ERR_INVALID_SIZE, 
                         append_frame(con->fullname(),Pane::set_size));
  con->set_size( nitems, ng);
}

Here is the call graph for this function:

Size size_i ( ) const

inline

Get the number of nodes in i-dimension if the mesh is structured.

Definition at line 216 of file Pane.h.

References _cnct_set, and is_structured().

Referenced by Element_node_enumerator::Element_node_enumerator(), Element_node_enumerator::id(), Element_node_enumerator::next(), Element_node_enumerator_str_2::next(), Element_node_enumerator::operator[](), Element_node_enumerator_str_2::operator[](), Pane_node_enumerator::Pane_node_enumerator(), Element_node_enumerator::vertex(), and write_attr_CGNS().

  { return !is_structured()?0:_cnct_set[0]->size_i(); }

Here is the call graph for this function:

Here is the caller graph for this function:

Size size_j ( ) const

inline

Get the number of nodes in j-dimension if the mesh is structured.

Definition at line 219 of file Pane.h.

References _cnct_set, and is_structured().

Referenced by Element_node_enumerator::Element_node_enumerator(), Pane_node_enumerator::Pane_node_enumerator(), Element_node_enumerator::vertex(), and write_attr_CGNS().

  { return !is_structured()?0:_cnct_set[0]->size_j(); }

Here is the call graph for this function:

Here is the caller graph for this function:

Size size_k ( ) const

inline

Get the number of nodes in k-dimension if the mesh is structured.

Definition at line 222 of file Pane.h.

References _cnct_set, and is_structured().

Referenced by Pane_node_enumerator::Pane_node_enumerator(), and write_attr_CGNS().

  { return !is_structured()?0:_cnct_set[0]->size_k(); }

Here is the call graph for this function:

Here is the caller graph for this function:

Size size_of_elements ( ) const

inline

Get the total number of elements in the pane (including ghost elements).

Definition at line 142 of file Pane.h.

References _attr_set, and COM_CONN.

Referenced by Element_node_enumerator::Element_node_enumerator().

  { return _attr_set[COM_CONN]->size_of_items(); }

Here is the caller graph for this function:

Size size_of_ghost_elements ( ) const

inline

Get the total number of ghost elements.

Definition at line 150 of file Pane.h.

References _attr_set, and COM_CONN.

  { return _attr_set[COM_CONN]->size_of_ghost_items(); }

Size size_of_ghost_layers ( ) const

inline

Dimension of the pane.

Get the number of ghost layers for structured mesh

Definition at line 212 of file Pane.h.

Referenced by Pane_node_enumerator::Pane_node_enumerator(), and write_attr_CGNS().

  { return _cnct_set.empty()?0:_cnct_set[0]->size_of_ghost_items(); }

Here is the caller graph for this function:

Size size_of_ghost_nodes ( ) const

inline

Get the number of ghost nodes.

Definition at line 126 of file Pane.h.

References _attr_set, and COM_NC.

Referenced by refresh_connectivity(), Connectivity::size_of_ghost_nodes(), and write_attr_CGNS().

  { return _attr_set[COM_NC]->size_of_ghost_items(); }

Here is the caller graph for this function:

Size size_of_nodes ( ) const

inline

Get the total number of nodes in the pane (including ghost nodes).

Definition at line 118 of file Pane.h.

Referenced by Pane_node_enumerator::Pane_node_enumerator(), refresh_connectivity(), Connectivity::size_of_nodes(), and write_attr_CGNS().

  { return _attr_set[COM_NC]->size_of_items(); }

Here is the caller graph for this function:

Size size_of_real_elements ( ) const

inline

Get the number of real elements in the pane (excluding ghost elements).

Definition at line 158 of file Pane.h.

References _attr_set, and COM_CONN.

Referenced by write_attr_CGNS().

  { return _attr_set[COM_CONN]->size_of_real_items(); }

Here is the caller graph for this function:

Size size_of_real_nodes ( ) const

inline

Get the number of real nodes in the pane (excluding ghost nodes).

Definition at line 134 of file Pane.h.

References _attr_set, and COM_NC.

Referenced by Connectivity::size_of_real_nodes(), and write_attr_CGNS().

  { return _attr_set[COM_NC]->size_of_real_items(); }

Here is the caller graph for this function:

const Window* window ( ) const

inline

Obtain a constant pointer to its owner window object.

Definition at line 91 of file Pane.h.

Referenced by Attribute::window().

{ return _window; }

Here is the caller graph for this function:

Window* window ( )

inline

Obtain a pointer to its owner window object.

Definition at line 93 of file Pane.h.

References _window.

{ return _window; }

double* x_coordinates ( )

inline

Get the pointer to the values of the x-coordinates, if the coordinates are staggered.

Definition at line 170 of file Pane.h.

References _attr_set, and COM_NC1.

{ return (double *)_attr_set[COM_NC1]->pointer(); }

const double* x_coordinates ( ) const

inline

Get a constant pointer to the values of the x-coordinates, if the coordinates are staggered.

Definition at line 183 of file Pane.h.

References _attr_set, and COM_NC1.

  { return (const double *)_attr_set[COM_NC1]->pointer(); }

double* y_coordinates ( )

inline

Get the pointer to the values of the y-coordinates, if the coordinates are staggered.

Definition at line 173 of file Pane.h.

References _attr_set, and COM_NC2.

{ return (double *)_attr_set[COM_NC2]->pointer(); }

const double* y_coordinates ( ) const

inline

Get a constant pointer to the values of the y-coordinates, if the coordinates are staggered.

Definition at line 187 of file Pane.h.

References _attr_set, and COM_NC2.

  { return (const double *)_attr_set[COM_NC2]->pointer(); }

double* z_coordinates ( )

inline

Get the pointer to the values of the z-coordinates, if the coordinates are staggered.

Definition at line 176 of file Pane.h.

References _attr_set, and COM_NC3.

{ return (double *)_attr_set[COM_NC3]->pointer(); }

const double* z_coordinates ( ) const

inline

Get a constant pointer to the values of the z-coordinates, if the coordinates are staggered.

Definition at line 191 of file Pane.h.

References _attr_set, and COM_NC3.

  { return (const double *)_attr_set[COM_NC3]->pointer(); }

Member Data Documentation

Attr_set _attr_set

protected

Set of attributes.

Definition at line 315 of file Pane.h.

Referenced by attribute(), attributes(), coordinates(), init_done(), maxsize_of_elements(), maxsize_of_ghost_elements(), maxsize_of_ghost_nodes(), maxsize_of_nodes(), maxsize_of_real_elements(), maxsize_of_real_nodes(), Pane(), pane_connectivity(), refresh_connectivity(), size_of_elements(), size_of_ghost_elements(), size_of_ghost_nodes(), size_of_real_elements(), size_of_real_nodes(), x_coordinates(), y_coordinates(), z_coordinates(), and ~Pane().

Cnct_set _cnct_set

protected

Set of element connectivity.

Definition at line 316 of file Pane.h.

Referenced by dimension(), is_mixed(), is_structured(), is_unstructured(), refresh_connectivity(), size_i(), size_j(), size_k(), and ~Pane().

int _id

protected

Pane id.

Definition at line 314 of file Pane.h.

Referenced by id().

bool _ignore_ghost

protected

Whether the ghosts were ignored.

Definition at line 317 of file Pane.h.

Referenced by ignore_ghost(), and set_ignore_ghost().

Window* _window

protected

Point to the parent window.

Definition at line 313 of file Pane.h.

Referenced by attribute(), init_done(), refresh_connectivity(), and window().

---

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

• Pane.h
• Pane.C