PartitionBoundary Class Reference

#include <Partition.H>

Inheritance diagram for PartitionBoundary:

Collaboration diagram for PartitionBoundary:

Public Member Functions
	PartitionBoundary ()
	PartitionBoundary (const GEM_PartitionBoundary &pb)
bool	ReadPartitionBoundary (ifstream &Inf)
bool	ReadPartitionBoundaryASCII (ifstream &Inf)
bool	WritePartitionBoundaryASCII (ofstream &Ouf)
unsigned int	MyRank (void) const
void	MyRank (unsigned int n)
void	populate_local_arrays (const PartitionBoundary &)
void	populate_local_arrays (const PartitionBoundary &rpb, GEM_Partition &gp)
Public Member Functions inherited from GEM_PartitionBoundary
void	report ()
void	populate (int rpid, int nnshared, int nnsend, int nnrecv, int ncsend, int ncrecv, int *sharedn, int *sendn, int *recvn, int *sendc, int *recvc)
	GEM_PartitionBoundary (const GEM_PartitionBoundary &pb)
	GEM_PartitionBoundary ()
GEM_PartitionBoundary &	operator= (const GEM_PartitionBoundary &pb)

Public Attributes
unsigned int	_mypart
unsigned int	_rbid
vector< pair< unsigned int, unsigned int > >	_bnodes
unsigned int	_ngnodes
vector< pair< unsigned int, unsigned int > >	_btets
unsigned int	_ngtets
vector< pair< unsigned int, unsigned int > >	_bhex
unsigned int	_nghex
vector< pair< unsigned int, unsigned int > >	_bpyr
unsigned int	_ngpyr
vector< pair< unsigned int, unsigned int > >	_bpris
unsigned int	_ngpris
vector< unsigned int >	_belem_send [4]
vector< unsigned int >	_belem_recv [4]
Public Attributes inherited from GEM_PartitionBoundary
unsigned int	_rpart
std::vector< unsigned int >	_sendcells
std::vector< unsigned int >	_recvcells
std::vector< unsigned int >	_sendnodes
std::vector< unsigned int >	_recvnodes
std::vector< unsigned int >	_sharenodes
GEM_UserData	_data
std::ostream *	_out
bool	_debug

Detailed Description

Definition at line 29 of file Partition.H.

Constructor & Destructor Documentation

PartitionBoundary ( )

inline

Definition at line 45 of file Partition.H.

    : GEM_PartitionBoundary()
  {};

PartitionBoundary ( const GEM_PartitionBoundary &  pb )

inline

Definition at line 48 of file Partition.H.

References _mypart, _ngnodes, _rbid, and GEM_PartitionBoundary::_recvnodes.

    : GEM_PartitionBoundary(pb)
  {
    _mypart  = 0;
    _rbid    = 0;
    _ngnodes = pb._recvnodes.size();
  };

Member Function Documentation

unsigned int MyRank ( void  ) const

inline

Definition at line 58 of file Partition.H.

References _mypart.

Referenced by Partition::ReadPartitionBoundaries().

{ return _mypart; };

Here is the caller graph for this function:

void MyRank ( unsigned int  n )

inline

Definition at line 59 of file Partition.H.

References _mypart, and n.

{_mypart = n;};

void populate_local_arrays

(

const PartitionBoundary &

rpb

)

Definition at line 1004 of file Partition.C.

References _bnodes, and _ngnodes.

{
  // Total number of nodes on this boundary (shared+send+recv)
  unsigned int nnodes = _bnodes.size();
  // Number of local reals is local total minus local ghosts
  unsigned int nreal = _bnodes.size() - _ngnodes;
  // Number of remote recv'd nodes
  unsigned int nremote_gnodes = rpb._ngnodes;
  // Number of local shared is local real - remote ghosts
  unsigned int nshared = nreal - nremote_gnodes;
  // Num remote real is remote total minus remote ghosts
  unsigned int nremote_rnodes = rpb._bnodes.size() - nremote_gnodes;
  // Num local send nodes must equal num remote ghosts
  unsigned int nsend = nreal - nshared;
  assert(nsend == nremote_gnodes);
  _recvnodes.resize(_ngnodes);
  _sharenodes.resize(nshared);
  _sendnodes.resize(nsend);
  //
  // We always let the sender determine the node ordering,
  // so the recv arrays need to be re-ordered so that they
  // match the remote border's node ordering.  Also, we
  // let the lesser of the two partition_id's determine the
  // shared node order.  
  //
  // The format for the data in _bnodes[] at this point is:
  //
  // vector<pair<LocalNodeIndex,RemoteBoundaryNodeIndex> >
  // 
  // And we want to populate the send, recv, and shared 
  // node arrays in the correct order.  For those that need
  // the remote ordering, we swap the pairs above and sort
  // the array based on the RemoteBoundaryNodeIndex (which
  // indexes into the remote partition's boundary node 
  // array).  Then we take a second pass to populate the 
  // local indices in that ordering.
  //
  // These hold the inverted local<-->remote node indices
  vector<pair<unsigned int,unsigned int> > recv_iindex;
  vector<pair<unsigned int,unsigned int> > shared_iindex;
  recv_iindex.resize(_ngnodes);
  shared_iindex.resize(nshared);
  unsigned int node = 0;
  unsigned int shnode = 0;
  unsigned int snode = 0;
  unsigned int rnode = 0;
  while(node < nnodes){
    // All ghost nodes are processed here
    if(node >= nreal)
      recv_iindex[rnode++] = make_pair(_bnodes[node].second,
                                       _bnodes[node].first);
    //      recv_iindex[rnode++] = _bnodes[node];
    else {
      if(_bnodes[node].second > nremote_rnodes)
        _sendnodes[snode++] = _bnodes[node].first;
      else {
        if(_mypart < _rpart) 
          _sharenodes[shnode++] = _bnodes[node].first;
        else
          shared_iindex[shnode++] = make_pair(_bnodes[node].second,
                                              _bnodes[node].first);
      }
    }
    node++;
  }
  sort(recv_iindex.begin(),recv_iindex.end());
  node = 0;
  while(node < rnode){
    _recvnodes[node] = recv_iindex[node].second;
    node++;
  }
  // Check partition_id (encoded as _myrank and _rrank) and order shared
  // nodes if needed.
  if(_mypart > _rpart){
    node = 0; 
    sort(shared_iindex.begin(),shared_iindex.end());
    while(node < shnode){
      _sharenodes[node] = shared_iindex[node].second;
      node++;
    }
  }

  // Nodes are done.  Now we need send and recv element arrays. These will be
  // done independently for each element type.  
  unsigned int ntets = _btets.size();
  unsigned int nhex  = _bhex.size();
  unsigned int npyr  = _bpyr.size();
  unsigned int npris = _bpris.size();
  unsigned int nreal_tets = ntets - _ngtets;
  unsigned int nreal_hex = nhex - _nghex;
  unsigned int nreal_pyr = npyr - _ngpyr;
  unsigned int nreal_pris = npris - _ngpris;
  _belem_send[0].resize(nreal_tets);
  _belem_send[1].resize(nreal_pyr);
  _belem_send[2].resize(nreal_pris);
  _belem_send[3].resize(nreal_hex);
  _belem_recv[0].resize(_ngtets);
  _belem_recv[1].resize(_ngpyr);
  _belem_recv[2].resize(_ngpris);
  _belem_recv[3].resize(_nghex);
  _sendcells.resize(nreal_tets+nreal_pyr+nreal_pris+nreal_hex);
  _recvcells.resize(_ngtets+_ngpyr+_ngpris+_nghex);
  unsigned int elem = 0;
  unsigned int selem = 0;
  unsigned int relem = 0;
  unsigned int scell = 0;
  unsigned int rcell = 0;
  recv_iindex.resize(_ngtets);
  while(elem < ntets){
    if(elem < nreal_tets){
      _belem_send[0][selem++] = _btets[elem].first;
      _sendcells[scell++] = _btets[elem].first;
    }
    else
      recv_iindex[relem++] = make_pair(_btets[elem].second,
                                       _btets[elem].first);
    elem++;
  }
  elem = 0;
  sort(recv_iindex.begin(),recv_iindex.end());
  while(elem < relem){
    _belem_recv[0][elem] = recv_iindex[elem].second;
    _recvcells[rcell++] = recv_iindex[elem].second;
    elem++;
  }
  assert((relem == _ngtets) && (selem == nreal_tets)); 
  elem = 0;
  selem = 0;
  relem = 0;
  recv_iindex.resize(_ngpyr);
  while(elem < npyr){
    if(elem < nreal_pyr){
      _belem_send[1][selem++] = _bpyr[elem].first;
      _sendcells[scell++] = _bpyr[elem].first + ntets;
    }
    else
      recv_iindex[relem++] = make_pair(_bpyr[elem].second,
                                       _bpyr[elem].first);
    elem++;
  }
  elem = 0;
  sort(recv_iindex.begin(),recv_iindex.end());
  while(elem < relem){
    _belem_recv[1][elem] = recv_iindex[elem].second;
    _recvcells[rcell++] = recv_iindex[elem].second + ntets;
    elem++;
  }
  assert((relem == _ngpyr) && (selem == nreal_pyr)); 
  elem = 0;
  selem = 0;
  relem = 0;
  recv_iindex.resize(_ngpris);
  while(elem < npris){
    if(elem < nreal_pris){
      _belem_send[2][selem++] = _bpris[elem].first;
      _sendcells[scell++] = _bpris[elem].first + ntets + npyr;
    }
    else
      recv_iindex[relem++] = make_pair(_bpris[elem].second,
                                       _bpris[elem].first);
    elem++;
  }
  elem = 0;
  sort(recv_iindex.begin(),recv_iindex.end());
  while(elem < relem){
    _belem_recv[2][elem] = recv_iindex[elem].second;
    _recvcells[rcell++] = recv_iindex[elem].second + ntets + npyr;
    elem++;
  }
  assert((relem == _ngpris) && (selem == nreal_pris)); 
  elem = 0;
  selem = 0;
  relem = 0;
  recv_iindex.resize(_nghex);
  while(elem < nhex){
    if(elem < nreal_hex){
      _belem_send[3][selem++] = _bhex[elem].first;
      _sendcells[scell++] = _bhex[elem].first+ntets+npyr+npris;
    }
    else
      recv_iindex[relem++] = make_pair(_bhex[elem].second,
                                       _bhex[elem].first);
    elem++;
  }
  elem = 0;
  sort(recv_iindex.begin(),recv_iindex.end());
  while(elem < relem){
    _belem_recv[3][elem] = recv_iindex[elem].second;
    _recvcells[rcell++] = recv_iindex[elem].second+ntets+npyr+npris;
    elem++;
  }
  assert((relem == _nghex) && (selem == nreal_hex)); 
}

void populate_local_arrays	(	const PartitionBoundary &	rpb,
		GEM_Partition &	gp
	)

Definition at line 794 of file Partition.C.

References _bnodes, GEM_Partition::_debug, _ngnodes, and GEM_Partition::Elem2Cell().

{
  bool debug = gp._debug;
  if(debug)
    cerr << "PartitionBoundary::populate_local_arrays entry" << endl;
  // Total number of nodes on this boundary (shared+send+recv)
  unsigned int nnodes = _bnodes.size();
  // Number of local reals is local total minus local ghosts
  unsigned int nreal = _bnodes.size() - _ngnodes;
  // Number of remote recv'd nodes
  unsigned int nremote_gnodes = rpb._ngnodes;
  // Number of local shared is local real - remote ghosts
  unsigned int nshared = nreal - nremote_gnodes;
  // Num remote real is remote total minus remote ghosts
  unsigned int nremote_rnodes = rpb._bnodes.size() - nremote_gnodes;
  // Num local send nodes must equal num remote ghosts
  unsigned int nsend = nreal - nshared;
  assert(nsend == nremote_gnodes);
  _recvnodes.resize(_ngnodes);
  _sharenodes.resize(nshared);
  _sendnodes.resize(nsend);
  //
  // We always let the sender determine the node ordering,
  // so the recv arrays need to be re-ordered so that they
  // match the remote border's node ordering.  Also, we
  // let the lesser of the two partition_id's determine the
  // shared node order.  
  //
  // The format for the data in _bnodes[] at this point is:
  //
  // vector<pair<LocalNodeIndex,RemoteBoundaryNodeIndex> >
  // 
  // And we want to populate the send, recv, and shared 
  // node arrays in the correct order.  For those that need
  // the remote ordering, we swap the pairs above and sort
  // the array based on the RemoteBoundaryNodeIndex (which
  // indexes into the remote partition's boundary node 
  // array).  Then we take a second pass to populate the 
  // local indices in that ordering.
  //
  // These hold the inverted local<-->remote node indices
  vector<pair<unsigned int,unsigned int> > recv_iindex;
  vector<pair<unsigned int,unsigned int> > shared_iindex;
  recv_iindex.resize(_ngnodes);
  shared_iindex.resize(nshared);
  unsigned int node = 0;
  unsigned int shnode = 0;
  unsigned int snode = 0;
  unsigned int rnode = 0;
  while(node < nnodes){
    // All ghost nodes are processed here
    if(node >= nreal)
      recv_iindex[rnode++] = make_pair(_bnodes[node].second,
                                       _bnodes[node].first);
    //      recv_iindex[rnode++] = _bnodes[node];
    else {
      if(_bnodes[node].second > nremote_rnodes)
        _sendnodes[snode++] = _bnodes[node].first;
      else {
        if(_mypart < _rpart) 
          _sharenodes[shnode++] = _bnodes[node].first;
        else
          shared_iindex[shnode++] = make_pair(_bnodes[node].second,
                                              _bnodes[node].first);
      }
    }
    node++;
  }
  sort(recv_iindex.begin(),recv_iindex.end());
  node = 0;
  while(node < rnode){
    _recvnodes[node] = recv_iindex[node].second;
    node++;
  }
  // Check partition_id (encoded as _myrank and _rrank) and order shared
  // nodes if needed.
  if(_mypart > _rpart){
    node = 0; 
    sort(shared_iindex.begin(),shared_iindex.end());
    while(node < shnode){
      _sharenodes[node] = shared_iindex[node].second;
      node++;
    }
  }
  if(debug)
    cerr << "PartitionBoundary::populate_local_arrays: Beginning elements."
         << endl;
  // Nodes are done.  Now we need send and recv element arrays. These will be
  // done independently for each element type.  
  unsigned int ntets = _btets.size();
  unsigned int nhex  = _bhex.size();
  unsigned int npyr  = _bpyr.size();
  unsigned int npris = _bpris.size();
  unsigned int nreal_tets = ntets - _ngtets;
  unsigned int nreal_hex = nhex - _nghex;
  unsigned int nreal_pyr = npyr - _ngpyr;
  unsigned int nreal_pris = npris - _ngpris;
  _belem_send[0].resize(nreal_tets);
  _belem_send[1].resize(nreal_pyr);
  _belem_send[2].resize(nreal_pris);
  _belem_send[3].resize(nreal_hex);
  _belem_recv[0].resize(_ngtets);
  _belem_recv[1].resize(_ngpyr);
  _belem_recv[2].resize(_ngpris);
  _belem_recv[3].resize(_nghex);
  _sendcells.resize(nreal_tets+nreal_pyr+nreal_pris+nreal_hex);
  _recvcells.resize(_ngtets+_ngpyr+_ngpris+_nghex);
  unsigned int elem = 0;
  unsigned int selem = 0;
  unsigned int relem = 0;
  unsigned int scell = 0;
  unsigned int rcell = 0;
  recv_iindex.resize(_ngtets);
  while(elem < ntets){
    if(elem < nreal_tets){
      _belem_send[0][selem++] = _btets[elem].first;
      _sendcells[scell++] = gp.Elem2Cell(make_pair((unsigned int)1,
                                                   _btets[elem].first));
    }
    else
      recv_iindex[relem++] = make_pair(_btets[elem].second,
                                       _btets[elem].first);
    elem++;
  }
  elem = 0;
  sort(recv_iindex.begin(),recv_iindex.end());
  while(elem < relem){
    _belem_recv[0][elem] = recv_iindex[elem].second;
    _recvcells[rcell++] = gp.Elem2Cell(make_pair((unsigned int)1,
                                                 recv_iindex[elem].second));
    elem++;
  }
  assert((relem == _ngtets) && (selem == nreal_tets)); 
  elem = 0;
  selem = 0;
  relem = 0;
  recv_iindex.resize(_ngpyr);
  while(elem < npyr){
    if(elem < nreal_pyr){
      _belem_send[1][selem++] = _bpyr[elem].first;
      _sendcells[scell++] = gp.Elem2Cell(make_pair((unsigned int)2,
                                                   _bpyr[elem].first));
    }
    else
      recv_iindex[relem++] = make_pair(_bpyr[elem].second,
                                       _bpyr[elem].first);
    elem++;
  }
  elem = 0;
  sort(recv_iindex.begin(),recv_iindex.end());
  while(elem < relem){
    _belem_recv[1][elem] = recv_iindex[elem].second;
    _recvcells[rcell++] = gp.Elem2Cell(make_pair((unsigned int)2,
                                                 recv_iindex[elem].second));
    elem++;
  }
  assert((relem == _ngpyr) && (selem == nreal_pyr)); 
  elem = 0;
  selem = 0;
  relem = 0;
  recv_iindex.resize(_ngpris);
  while(elem < npris){
    if(elem < nreal_pris){
      _belem_send[2][selem++] = _bpris[elem].first;
      _sendcells[scell++] = gp.Elem2Cell(make_pair((unsigned int)3,
                                                   _bpris[elem].first));
    }
    else
      recv_iindex[relem++] = make_pair(_bpris[elem].second,
                                       _bpris[elem].first);
    elem++;
  }
  elem = 0;
  sort(recv_iindex.begin(),recv_iindex.end());
  while(elem < relem){
    _belem_recv[2][elem] = recv_iindex[elem].second;
    _recvcells[rcell++] = gp.Elem2Cell(make_pair((unsigned int)3,
                                                 recv_iindex[elem].second));
    elem++;
  }
  assert((relem == _ngpris) && (selem == nreal_pris)); 
  elem = 0;
  selem = 0;
  relem = 0;
  recv_iindex.resize(_nghex);
  while(elem < nhex){
    if(elem < nreal_hex){
      _belem_send[3][selem++] = _bhex[elem].first;
      _sendcells[scell++] = gp.Elem2Cell(make_pair((unsigned int)4,
                                                   _bhex[elem].first));
    }
    else
      recv_iindex[relem++] = make_pair(_bhex[elem].second,
                                       _bhex[elem].first);
    elem++;
  }
  elem = 0;
  sort(recv_iindex.begin(),recv_iindex.end());
  while(elem < relem){
    _belem_recv[3][elem] = recv_iindex[elem].second;
    _recvcells[rcell++] = gp.Elem2Cell(make_pair((unsigned int)4,
                                                 recv_iindex[elem].second));
    elem++;
  }
  assert((relem == _nghex) && (selem == nreal_hex)); 
}

Here is the call graph for this function:

bool ReadPartitionBoundary

(

ifstream &

Inf

)

Definition at line 172 of file Partition.C.

Referenced by Partition::ReadPartitionBoundaries().

{
    int buf[4];
    Inf.read(reinterpret_cast<char *>(buf),16);
    _rpart      = buf[0];
    _rbid       = buf[1];
    int nnodes  = buf[2];
    _ngnodes    = buf[3];

    _bnodes.resize(nnodes);
    int *nbuf = new int [2 * nnodes];
    Inf.read(reinterpret_cast<char *>(nbuf),8*nnodes);

    int node = 0;
    while(node < nnodes){
      _bnodes[node] = make_pair(nbuf[2*node],nbuf[2*node+1]);
      node++;
    }
    delete [] nbuf;

    Inf.read(reinterpret_cast<char *>(buf),8);
    int nelem = buf[0];
    _ngtets   = buf[1];
    _btets.resize(nelem);
    nbuf = new int [2*nelem];
    Inf.read(reinterpret_cast<char *>(nbuf),nelem*8);
    int elem = 0;
    while(elem < nelem){
      _btets[elem] = make_pair(nbuf[2*elem],nbuf[2*elem+1]);
      elem++;
    }
    delete [] nbuf;

    Inf.read(reinterpret_cast<char *>(buf),8);
    nelem = buf[0];
    _ngpyr   = buf[1];
    _bpyr.resize(nelem);
    nbuf = new int [2*nelem];
    Inf.read(reinterpret_cast<char *>(nbuf),nelem*8);
    elem = 0;
    while(elem < nelem){
      _bpyr[elem] = make_pair(nbuf[2*elem],nbuf[2*elem+1]);
      elem++;
    }
    delete [] nbuf;

    Inf.read(reinterpret_cast<char *>(buf),8);
    nelem = buf[0];
    _ngpris   = buf[1];
    _bpris.resize(nelem);
    nbuf = new int [2*nelem];
    Inf.read(reinterpret_cast<char *>(nbuf),nelem*8);
    elem = 0;
    while(elem < nelem){
      _bpris[elem] = make_pair(nbuf[2*elem],nbuf[2*elem+1]);
      elem++;
    }
    delete [] nbuf;

    Inf.read(reinterpret_cast<char *>(buf),8);
    nelem = buf[0];
    _nghex   = buf[1];
    _bhex.resize(nelem);
    nbuf = new int [2*nelem];
    Inf.read(reinterpret_cast<char *>(nbuf),nelem*8);
    elem = 0;
    while(elem < nelem){
      _bhex[elem] = make_pair(nbuf[2*elem],nbuf[2*elem+1]);
      elem++;
    }
    delete [] nbuf;
    
    return(true);
}

Here is the caller graph for this function:

bool ReadPartitionBoundaryASCII

(

ifstream &

Inf

)

Definition at line 248 of file Partition.C.

Referenced by Partition::ReadPartitionBoundariesASCII().

{
  int nnodes  = 0;
  Inf >> _rpart >> _rbid >> nnodes >> _ngnodes;
  _rpart += 1; // This converts to the required 1-based id's
  _bnodes.resize(nnodes);
  int node = 0;
  int l,r;
  while(node < nnodes){
    Inf >> l >> r;
    _bnodes[node++] = make_pair(l,r);
  }

  int nelem = 0;
  Inf >> nelem >> _ngtets;
  _btets.resize(nelem);
  int elem = 0;
  while(elem < nelem){
    Inf >> l >> r;
    _btets[elem++] = make_pair(l,r);
  }
  
  nelem = 0;
  Inf >> nelem >> _ngpyr;
  _bpyr.resize(nelem);
  elem = 0;
  while(elem < nelem){
    Inf >> l >> r;
    _bpyr[elem++] = make_pair(l,r);
  }
  
  nelem = 0;
  Inf >> nelem >> _ngpris;
  _bpris.resize(nelem);
  elem = 0;
  while(elem < nelem){
    Inf >> l >> r;
    _bpris[elem++] = make_pair(l,r);
  }
  
  nelem = 0;
  Inf >> nelem >> _nghex;
  _bhex.resize(nelem);
  elem = 0;
  while(elem < nelem){
    Inf >> l >> r;
    _bhex[elem++] = make_pair(l,r);
  }
  
  return(true);
}

Here is the caller graph for this function:

bool WritePartitionBoundaryASCII

(

ofstream &

Ouf

)

Definition at line 301 of file Partition.C.

Referenced by Partition::WritePartitionBoundariesASCII().

{
  unsigned int nelem = _bnodes.size();
  Ouf << setw(12) << _rpart-1 << endl
      << setw(12) << _rbid << endl
      << setw(12) << nelem << endl 
      << setw(12) << _ngnodes << endl;
  unsigned int node = 0;
  while(node < nelem){
    Ouf << setw(12) << _bnodes[node].first 
        << setw(12) << _bnodes[node].second
        << endl;
    node++;
  }
  nelem = _btets.size();
  Ouf << setw(12) << nelem << endl
      << setw(12) << _ngtets << endl;
  unsigned int elem = 0;
  while(elem < nelem){
    Ouf << setw(12) << _btets[elem].first
        << setw(12) << _btets[elem].second
        << endl;
    elem++;
  }
  
  nelem = _bpyr.size();
  Ouf <<  setw(12) << nelem << endl
      << setw(12) << _ngpyr << endl;
  elem = 0;
  while(elem < nelem){
    Ouf << setw(12) << _bpyr[elem].first
        << setw(12) << _bpyr[elem].second
        << endl;
    elem++;
  }
  nelem = _bpris.size();
  Ouf << setw(12) << nelem << endl
      << setw(12) << _ngpris << endl;
  elem = 0;
  while(elem < nelem){
    Ouf << setw(12) << _bpris[elem].first
        << setw(12) << _bpris[elem].second
        << endl;
    elem++;
  }
  nelem = _bhex.size();
  Ouf << setw(12) << nelem << endl
      << setw(12) << _nghex << endl;
  elem = 0;
  while(elem < nelem){
    Ouf << setw(12) << _bhex[elem].first
        << setw(12) << _bhex[elem].second
        << endl;
    elem++;
  }
  return(true);
}

Here is the caller graph for this function:

Member Data Documentation

vector<unsigned int> _belem_recv[4]

Definition at line 44 of file Partition.H.

Referenced by Partition::BuildPartitionBoundaries().

vector<unsigned int> _belem_send[4]

Definition at line 43 of file Partition.H.

Referenced by Partition::BuildPartitionBoundaries().

vector< pair<unsigned int, unsigned int> > _bhex

Definition at line 37 of file Partition.H.

vector< pair<unsigned int,unsigned int> > _bnodes

Definition at line 33 of file Partition.H.

Referenced by populate_local_arrays().

vector< pair<unsigned int, unsigned int> > _bpris

Definition at line 41 of file Partition.H.

vector< pair<unsigned int, unsigned int> > _bpyr

Definition at line 39 of file Partition.H.

vector< pair<unsigned int,unsigned int> > _btets

Definition at line 35 of file Partition.H.

unsigned int _mypart

Definition at line 31 of file Partition.H.

Referenced by MyRank(), and PartitionBoundary().

unsigned int _nghex

Definition at line 38 of file Partition.H.

unsigned int _ngnodes

Definition at line 34 of file Partition.H.

Referenced by PartitionBoundary(), and populate_local_arrays().

unsigned int _ngpris

Definition at line 42 of file Partition.H.

unsigned int _ngpyr

Definition at line 40 of file Partition.H.

unsigned int _ngtets

Definition at line 36 of file Partition.H.

unsigned int _rbid

Definition at line 32 of file Partition.H.

Referenced by PartitionBoundary().

---

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

• Partition.H
• Partition.C