#include <Partition.H>

Inheritance diagram for Partition:

Collaboration diagram for Partition:

Public Member Functions
bool	ReadPartition (const string &pre, unsigned int rank)

bool	ReadPartitionBoundaries (ifstream &Inf)

bool	ReadPartitionPatches (ifstream &Inf)

bool	ReadPartitionASCII (const string &pre, unsigned int rank)

bool	ReadPartitionBoundariesASCII (ifstream &Inf)

bool	ReadPartitionPatchesASCII (ifstream &Inf)

bool	WritePartitionASCII (const string &pre)

bool	WritePartitionBoundariesASCII (ofstream &Ouf)

bool	WritePartitionPatchesASCII (ofstream &Ouf)

bool	BuildPartitionBoundaries (const vector< int > &Pconn)

	Partition (const GEM_Partition &gp)

	Partition ()

Public Member Functions inherited from GEM_Partition
bool	validate_comm_list (int ncsend, int ncrecv, int csend, int crecv)

bool	ValidateMesh ()

void	AddParitionBoundary (int rpid, int nnshare, int nnsend, int nnrecv, int ncsend, int ncrecv, int nshared, int nsend, int nrecv, int csend, int *crecv)

void	AddDomainBoundary (int db_id, int ntri, int ngtri, int tris, int nquad, int ngquad, int quads)

bool	SetSolverDataBlock (const std::string &wname, double cell_data, int nval_cells, double node_data, int nval_nodes)

bool	AddSolverDataBlock (const std::string &wname, double cell_data, int nval_cells, double node_data, int nval_nodes)

bool	debug (bool s=true)

void	ResolveCellMapping (GEM_Partition &sp)

void	SetNodalCoordinates (double *data, int nn, int ng)

void	SetVolumeElements (int *data, int ncells, int ng, int npe)

bool	PopulatePartitionBoundaries (std::vector< GEM_PartitionBoundary > &pb)

void	MapDomainBoundaries (std::map< unsigned int, unsigned int > &bcmap)

void	report ()

void	report_partition_boundaries ()

void	report_domain_boundaries ()

unsigned int	nelem ()

unsigned int	Elem2Cell (std::pair< unsigned int, unsigned int >)

std::pair< unsigned int, unsigned int >	Cell2Elem (unsigned int)

void	Register_com_volconn (const std::string &wname, int paneid, unsigned int nel, unsigned int ngel, std::vector< unsigned int > &conn, unsigned int esize, bool ghost_part=false)

bool	WindowInitDone ()

bool	DestroyWindows ()

bool	WriteRocstar (const std::string &, double t=0.0)

bool	ReadRocstar (const std::string &, double t=0.0)

bool	InitRoccomWindows (const std::string &wname)

void	Create_com_pconn (std::vector< unsigned int > rpids, std::vector< std::vector< std::vector< unsigned int > > > &index_vectors, unsigned int &nreal, unsigned int &ng, std::vector< int > &pc)

bool	CreatePconn (const std::string &wname)

bool	PopulateVolumeWindow (const std::string &wname)

bool	PopulateSurfaceWindow (const std::string &wname)

void	Create_com_volsoln (const std::string &fname, std::vector< double > &fvec, unsigned int ncomp, const std::string &unit)

	GEM_Partition (const GEM_Partition &gp)

	GEM_Partition ()

	GEM_Partition (unsigned int id, MPI_Comm comm=MPI_COMM_NULL)

GEM_Partition &	operator= (const GEM_Partition &gp)

Public Attributes
unsigned int	_nnodes

unsigned int	_nelem

unsigned int	_ntet

unsigned int	_nhex

unsigned int	_npyr

unsigned int	_npris

unsigned int	_npatch

vector< PartitionBoundary >	_boundaries

vector< PartitionPatch >	_patches

Public Attributes inherited from GEM_Partition
unsigned int	_id

unsigned int	_npart

unsigned int	_ngnodes

unsigned int	_ngtet

unsigned int	_nghex

unsigned int	_ngpyr

unsigned int	_ngpris

unsigned int	_nvface

std::vector< double >	_nc

std::vector< unsigned int >	_tetconn

std::vector< unsigned int >	_pyrconn

std::vector< unsigned int >	_prisconn

std::vector< unsigned int >	_hexconn

unsigned int	_cell_ordering [4]

std::vector < GEM_PartitionBoundary >	_pb

std::vector< GEM_DomainBoundary >	_db

GEM_UserData	_data

GEM_UserData	_solver_data

std::ostream *	_out

bool	_debug

MPI_Comm	_comm

int	pane_id

std::vector< int >	pconn

unsigned int	pconn_nghost

std::string	volume_window

std::string	surface_window

Detailed Description

Definition at line 91 of file Partition.H.

Constructor & Destructor Documentation

Partition ( const GEM_Partition & gp )

Partition ( )

inline

Definition at line 113 of file Partition.H.

114 {};

Member Function Documentation

bool BuildPartitionBoundaries ( const vector< int > & Pconn )

Definition at line 523 of file Partition.C.

References PartitionBoundary::_belem_recv, PartitionBoundary::_belem_send, GEM_PartitionBoundary::_recvcells, GEM_PartitionBoundary::_recvnodes, GEM_PartitionBoundary::_rpart, GEM_PartitionBoundary::_sendcells, GEM_PartitionBoundary::_sendnodes, and GEM_PartitionBoundary::_sharenodes.

 {
   unsigned int index = 0;
   unsigned int npb = Pconn[index++];
   _boundaries.clear();
   _boundaries.resize(npb);
   
   // Shared Nodes
   unsigned int pb_index = 0;
   while(pb_index < npb){
     PartitionBoundary &pb = _boundaries[pb_index++];
     unsigned int pane_id = Pconn[index++];
     pb._rpart  = pane_id/100;
     //    pb._mypart = _part;
     //    pb._rbid   = pane_id%100;
     unsigned int nshared = Pconn[index++];
     pb._sharenodes.resize(nshared);
     unsigned int node = 0;
     while(node < nshared)
       pb._sharenodes[node++] = Pconn[index++];
   }
   index++;
 
   // Send Nodes
   pb_index = 0;
   while(pb_index < npb){
     PartitionBoundary &pb = _boundaries[pb_index++];
     unsigned int pane_id = Pconn[index++];
     assert(pb._rpart == pane_id/100);
     unsigned int nsend = Pconn[index++];
     pb._sendnodes.resize(nsend);
     unsigned int node = 0;
     while(node < nsend)
       pb._sendnodes[node++] = Pconn[index++];
   }
   index++;
 
   // Recv Nodes
   pb_index = 0;
   while(pb_index < npb){
     PartitionBoundary &pb = _boundaries[pb_index++];
     unsigned int pane_id = Pconn[index++];
     assert(pb._rpart == pane_id/100);
     unsigned int nrecv = Pconn[index++];
     pb._recvnodes.resize(nrecv);
     unsigned int node = 0;
     while(node < nrecv)
       pb._recvnodes[node++] = Pconn[index++];
   }
   index++;
 
   // Send Elems - first, we have to populate a temprorary array
   // then, we have to sort through the array and determine how
   // many of each element type there are.
   pb_index = 0;
   while(pb_index < npb){
     PartitionBoundary &pb = _boundaries[pb_index++];
     unsigned int pane_id = Pconn[index++];
     assert(pb._rpart == pane_id/100);
     unsigned int nsend = Pconn[index++];
     pb._sendcells.resize(nsend);
     unsigned int node = 0;
     while(node < nsend)
       pb._sendcells[node++] = Pconn[index++];
     // Now temp_id contains the mapped element id
     // We need to know whether each element is a 
     // tet, pyr, pris, or hex and keep a count.
     node = 0;
     unsigned int ntet = 0;
     unsigned int npyr = 0;
     unsigned int npris = 0;
     unsigned int nhex = 0;
     while(node < nsend){
       if(pb._sendcells[node] <= _ntet)
         ntet++;
       else if (pb._sendcells[node] <= (_ntet+_npyr))
         npyr++;
       else if (pb._sendcells[node] <= (_ntet+_npyr+_npris))
         npris++;
       else if (pb._sendcells[node] <= (_ntet+_npyr+_npris+_nhex))
         nhex++;
       else
         assert(pb._sendcells[node] <= (_ntet+_npyr+_npris+_nhex));
       node++;
     }
     pb._belem_send[0].resize(ntet);
     pb._belem_send[1].resize(npyr);
     pb._belem_send[2].resize(npris);
     pb._belem_send[3].resize(nhex);
     node = 0;
     ntet = 0;
     npyr = 0;
     npris = 0;
     nhex = 0;
     while(node < nsend){
       if(pb._sendcells[node] <= _ntet)
         pb._belem_send[0][ntet++] = pb._sendcells[node];
       else if (pb._sendcells[node] <= (_ntet+_npyr))
         pb._belem_send[1][npyr++] = pb._sendcells[node] - _ntet;
       else if (pb._sendcells[node] <= (_ntet+_npyr+_npris))
         pb._belem_send[2][npris++] = pb._sendcells[node] - (_ntet+_npyr);
       else 
         pb._belem_send[3][nhex++]  = pb._sendcells[node] - (_ntet+_npyr+_npris);
       node++;
     }
   }
   index++;
 
   // Recv Elems - first, we have to populate a temprorary array
   // then, we have to sort through the array and determine how
   // many of each element type there are.  Then we populate the 
   // array
   pb_index = 0;
   while(pb_index < npb){
     PartitionBoundary &pb = _boundaries[pb_index++];
     unsigned int pane_id = Pconn[index++];
     assert(pb._rpart == pane_id/100);
     unsigned int nrecv = Pconn[index++];
     pb._recvcells.resize(nrecv);
     unsigned int node = 0;
     while(node < nrecv)
       pb._recvcells[node++] = Pconn[index++];
     // Now pb._recvcells contains the mapped element id
     // We need to know whether each element is a 
     // tet, pyr, pris, or hex and keep a count.
     node = 0;
     unsigned int ntet = 0;
     unsigned int npyr = 0;
     unsigned int npris = 0;
     unsigned int nhex = 0;
     while(node < nrecv){
       if(pb._recvcells[node] <= _ntet)
         ntet++;
       else if (pb._recvcells[node] <= (_ntet+_npyr))
         npyr++;
       else if (pb._recvcells[node] <= (_ntet+_npyr+_npris))
         npris++;
       else if (pb._recvcells[node] <= (_ntet+_npyr+_npris+_nhex))
         nhex++;
       else
         assert(pb._recvcells[node] <= (_ntet+_npyr+_npris+_nhex));
       node++;
     }
     pb._belem_recv[0].resize(ntet);
     pb._belem_recv[1].resize(npyr);
     pb._belem_recv[2].resize(npris);
     pb._belem_recv[3].resize(nhex);
     node = 0;
     ntet = 0;
     npyr = 0;
     npris = 0;
     nhex = 0;
     while(node < nrecv){
       if(pb._recvcells[node] <= _ntet)
         pb._belem_recv[0][ntet++] = pb._recvcells[node];
       else if (pb._recvcells[node] <= (_ntet+_npyr))
         pb._belem_recv[1][npyr++] = pb._recvcells[node] - _ntet;
       else if (pb._recvcells[node] <= (_ntet+_npyr+_npris))
         pb._belem_recv[2][npris++] = pb._recvcells[node] - (_ntet+_npyr);
       else 
         pb._belem_recv[3][nhex++]  = pb._recvcells[node] - (_ntet+_npyr+_npris);
       node++;
     }
   }
   return(true);
 }

bool ReadPartition	(	const string &	pre,
		unsigned int	rank
	)

Definition at line 402 of file Partition.C.

References rank.

 {
   ifstream Inf;
   ostringstream Ostr;
 
   Ostr << pre << "." << rank;
   Inf.open(Ostr.str().c_str());
   if(!Inf) return(false);
   
   long buf[2];
   this->_id = rank;
   Inf.read(reinterpret_cast<char *>(&buf[0]),8);
   this->_nnodes = buf[0];
   cout << "buf[0] = " << buf[0] << endl;
   this->_ngnodes = buf[1];
   // skip over coordinates 3 of 4 bytes for each node
   Inf.seekg(this->_nnodes * 3 * 4,ios::cur);
   Inf.read(reinterpret_cast<char *>(buf),8);
   this->_ntet = buf[0];
   this->_ngtet = buf[1];
   // skip over connectivity 4 of 4 bytes for each tet
   Inf.seekg(this->_ntet * 4 * 4,ios::cur);
   Inf.read(reinterpret_cast<char *>(buf),8);
   this->_npyr = buf[0];
   this->_ngpyr = buf[1];
   // skip over connectivity 5 of 4 bytes for each pyr
   Inf.seekg(this->_npyr * 5 * 4,ios::cur);
   Inf.read(reinterpret_cast<char *>(buf),8);
   this->_npris = buf[0];
   this->_ngpris = buf[1];
   // skip over connectivity 6 of 4 bytes for each pris
   Inf.seekg(this->_npris * 6 * 4,ios::cur);
   Inf.read(reinterpret_cast<char *>(buf),8);
   this->_nhex = buf[0];
   this->_nghex = buf[1];
   // skip over connectivity 8 of 4 bytes for each hex
   Inf.seekg(this->_nhex * 8 * 4,ios::cur);
   this->_nelem = this->_nhex + this->_ntet + this->_npyr + this->_npris;
   int nbound = 0;
   Inf.read(reinterpret_cast<char *>(&nbound),4);
   _boundaries.resize(nbound);
   if(!ReadPartitionBoundaries(Inf))
     return(false);
   if(!ReadPartitionPatches(Inf))
     return(false);
   Inf.close();
   return(true);
 }

bool ReadPartitionASCII	(	const string &	pre,
		unsigned int	rank
	)

Definition at line 452 of file Partition.C.

 {
   ifstream Inf;
   ostringstream Ostr;
 
   Ostr << pre << "." << rank << ".asc";
   Inf.open(Ostr.str().c_str());
   if(!Inf){
     cerr << "Cannot open " << Ostr.str() << "." << endl;
     return(false);
   }
  
   _id = rank + 1;
   unsigned int nvfaces,nbfaces;
   Inf >> nvfaces >> nbfaces >> _nnodes >> _ngnodes;
   _nvface =  nvfaces + nbfaces;
   unsigned int node = 0;
   _nc.resize(3*_nnodes);
   while(node < _nnodes){
     Inf >> _nc[3*node] >> _nc[3*node+1] >> _nc[3*node+2];
     node++;
   }
   Inf >> _ntet >> _ngtet;
   unsigned int tet = 0;
   _tetconn.resize(4*_ntet);
   while(tet < _ntet){
     Inf >> _tetconn[4*tet] >> _tetconn[4*tet+1] >> _tetconn[4*tet+2]
         >> _tetconn[4*tet+3];
     tet++;
   }
   Inf >> _npyr >> _ngpyr;
   unsigned int pyr = 0;
   _pyrconn.resize(5*_npyr);
   while(pyr < _npyr){
     Inf >> _pyrconn[5*pyr] >> _pyrconn[5*pyr+1] >> _pyrconn[5*pyr+2]
         >> _pyrconn[5*pyr+3] >> _pyrconn[5*pyr+4];
     pyr++;
   }
 
   Inf >> _npris >> _ngpris;
   unsigned int pris = 0;
   _prisconn.resize(6*_npris);
   while(pris < _npris){
     Inf >> _prisconn[6*pris] >> _prisconn[6*pris+1] >> _prisconn[6*pris+2]
         >> _prisconn[6*pris+3] >> _prisconn[6*pris+4] 
         >> _prisconn[6*pris+5];
     pris++;
   }
 
   Inf >> _nhex >> _nghex;
   unsigned int hex = 0;
   _hexconn.resize(8*_nhex);
   while(hex < _nhex){
     Inf >> _hexconn[8*hex] >> _hexconn[8*hex+1] >> _hexconn[8*hex+2]
         >> _hexconn[8*hex+3] >> _hexconn[8*hex+4] 
         >> _hexconn[8*hex+5] >> _hexconn[8*hex+6] >> _hexconn[8*hex+7];
     hex++;
   }
   _nelem = _nhex + _ntet + _npyr + _npris;
   unsigned int nbound = 0;
   Inf >> nbound;
   _boundaries.resize(nbound);
   if(!ReadPartitionBoundariesASCII(Inf))
     return(false);
   if(!ReadPartitionPatchesASCII(Inf))
     return(false);
   Inf.close();
   return(true);
 }

bool ReadPartitionBoundaries ( ifstream & Inf )

Definition at line 387 of file Partition.C.

References PartitionBoundary::MyRank(), and PartitionBoundary::ReadPartitionBoundary().

 {
   int nbound = _boundaries.size();
   int bound = 0;
   while(bound < nbound){
     PartitionBoundary *pb = &_boundaries[bound++];
     if(!pb->ReadPartitionBoundary(Inf))
       return(false);
     pb->MyRank(_id);
   }
   return(true);
 }

Here is the call graph for this function:

bool ReadPartitionBoundariesASCII ( ifstream & Inf )

Definition at line 360 of file Partition.C.

References PartitionBoundary::ReadPartitionBoundaryASCII().

 {
   int nbound = _boundaries.size();
   int bound = 0;
   while(bound < nbound){
     PartitionBoundary *pb = &_boundaries[bound++];
     if(!pb->ReadPartitionBoundaryASCII(Inf))
       return(false);
     //    pb->MyRank(_rank);
   }
   return(true);
 }

Here is the call graph for this function:

bool ReadPartitionPatches ( ifstream & Inf )

Definition at line 125 of file Partition.C.

References PartitionPatch::ReadPartitionPatch().

 {
   //  map<unsigned int, unsigned int> patch_mapping;
   //  if(!build_patch_mapping(pre,patch_mapping))
   //    return false;
   int nlocal_patches;
   Inf.read(reinterpret_cast<char *>(&nlocal_patches),4);
   _patches.resize(nlocal_patches);
   int bound = 0;
   while(bound < nlocal_patches){
     PartitionPatch *pp = &_patches[bound++];
     if(!pp->ReadPartitionPatch(Inf))
       return(false);
   }
   return(true);
 }

Here is the call graph for this function:

bool ReadPartitionPatchesASCII ( ifstream & Inf )

Definition at line 143 of file Partition.C.

References PartitionPatch::ReadPartitionPatchASCII().

 {
   int nlocal_patches;
   Inf >> nlocal_patches;
   _patches.resize(nlocal_patches);
   int bound = 0;
   while(bound < nlocal_patches){
     PartitionPatch *pp = &_patches[bound++];
     if(!pp->ReadPartitionPatchASCII(Inf))
       return(false);
   }
   return(true);
 }

Here is the call graph for this function:

bool WritePartitionASCII ( const string & pre )

Definition at line 691 of file Partition.C.

 {
   ofstream Ouf;
   ostringstream Ostr;
 
   Ostr << pre << "." << _id-1 << ".asc";
   Ouf.open(Ostr.str().c_str());
   if(!Ouf){
     cerr << "Cannot open " << Ostr.str() << "." << endl;
     return(false);
   }
   
 
   Ouf << setw(12) << _nvface
       << setw(12) << 0
       << setw(12) << _nnodes 
       << setw(12) << _ngnodes
       << endl;
   unsigned int node = 0;
   while(node < _nnodes){
     Ouf << setw(20) <<  _nc[3*node] 
         << setw(20) <<  _nc[3*node+1] 
         << setw(20) <<  _nc[3*node+2]
         << endl;
     node++;
   }
   Ouf << setw(12) << _ntet 
       << setw(12) << _ngtet
       << endl;
   unsigned int tet = 0;
   while(tet < _ntet){
     Ouf << setw(12) << _tetconn[4*tet] 
         << setw(12) << _tetconn[4*tet+1]
         << setw(12) << _tetconn[4*tet+2]
         << setw(12) <<  _tetconn[4*tet+3]
         << endl;
     tet++;
   }
   Ouf << setw(12) << _npyr
       << setw(12) << _ngpyr 
       << endl;
   unsigned int pyr = 0;
   while(pyr < _npyr){
     Ouf << setw(12) << _pyrconn[5*pyr] 
         << setw(12) << _pyrconn[5*pyr+1] 
         << setw(12) << _pyrconn[5*pyr+2]
         << setw(12) << _pyrconn[5*pyr+3] 
         << setw(12) << _pyrconn[5*pyr+4]
         << endl;
     pyr++;
   }
 
   Ouf << setw(12) << _npris 
       << setw(12) << _ngpris
       << endl;
   unsigned int pris = 0;
   while(pris < _npris){
     Ouf << setw(12) << _prisconn[6*pris] 
         << setw(12) << _prisconn[6*pris+1] 
         << setw(12) << _prisconn[6*pris+2]
         << setw(12) << _prisconn[6*pris+3] 
         << setw(12) << _prisconn[6*pris+4] 
         << setw(12) << _prisconn[6*pris+5]
         << endl;
     pris++;
   }
 
   Ouf << setw(12) <<  _nhex 
       << setw(12) <<  _nghex
       << endl;
   unsigned int hex = 0;
   while(hex < _nhex){
     Ouf << setw(12) << _hexconn[8*hex] 
         << setw(12) << _hexconn[8*hex+1]
         << setw(12) << _hexconn[8*hex+2]
         << setw(12) << _hexconn[8*hex+3]
         << setw(12) << _hexconn[8*hex+4] 
         << setw(12) << _hexconn[8*hex+5]
         << setw(12) << _hexconn[8*hex+6] 
         << setw(12) << _hexconn[8*hex+7]
         << endl;
     hex++;
   }
   Ouf << _boundaries.size() << endl;
   if(!WritePartitionBoundariesASCII(Ouf))
     return(false);
   if(!WritePartitionPatchesASCII(Ouf))
     return(false);
   Ouf.close();
   return(true);
 }

bool WritePartitionBoundariesASCII ( ofstream & Ouf )

Definition at line 374 of file Partition.C.

References PartitionBoundary::WritePartitionBoundaryASCII().

 {
   int nbound = _boundaries.size();
   int bound = 0;
   while(bound < nbound){
     PartitionBoundary *pb = &_boundaries[bound++];
     if(!pb->WritePartitionBoundaryASCII(Ouf))
       return(false);
   }
   return(true);
 }

Here is the call graph for this function:

bool WritePartitionPatchesASCII ( ofstream & Ouf )

Definition at line 159 of file Partition.C.

References PartitionPatch::WritePartitionPatchASCII().

 {
   Ouf << setw(12) << _patches.size() << endl;
   unsigned int bound = 0;
   while(bound < _patches.size()){
     PartitionPatch *pp = &_patches[bound++];
     if(!pp->WritePartitionPatchASCII(Ouf))
       return(false);
   }
   return(true);
 }

Here is the call graph for this function:

Member Data Documentation

vector<PartitionBoundary> _boundaries

Definition at line 100 of file Partition.H.

unsigned int _nelem

Definition at line 94 of file Partition.H.

unsigned int _nhex

Definition at line 96 of file Partition.H.

unsigned int _nnodes

Definition at line 93 of file Partition.H.

unsigned int _npatch

Definition at line 99 of file Partition.H.

unsigned int _npris

Definition at line 98 of file Partition.H.

unsigned int _npyr

Definition at line 97 of file Partition.H.

unsigned int _ntet

Definition at line 95 of file Partition.H.

vector<PartitionPatch> _patches

Definition at line 101 of file Partition.H.

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

Public Member Functions

Public Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation