#include <GEM.H>

Inheritance diagram for GEM_Partition:

Collaboration diagram for GEM_Partition:

Public Member Functions
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	_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 282 of file GEM.H.

Constructor & Destructor Documentation

GEM_Partition ( const GEM_Partition & gp )

inline

Definition at line 420 of file GEM.H.

References _cell_ordering, _comm, _debug, _hexconn, _id, _nc, _nghex, _ngnodes, _ngpris, _ngpyr, _ngtet, _nvface, _out, _prisconn, _pyrconn, and _tetconn.

   {
     _out      = gp._out;
     _id       = gp._id;
     _ngnodes  = gp._ngnodes;
     _ngtet    = gp._ngtet;
     _nghex    = gp._nghex;
     _ngpyr    = gp._ngpyr;
     _ngpris   = gp._ngpris;
     _nc       = gp._nc;
     _tetconn  = gp._tetconn;
     _pyrconn  = gp._pyrconn;
     _prisconn = gp._prisconn;
     _hexconn  = gp._hexconn;
     _nvface   = gp._nvface;
     _debug    = gp._debug;
     _cell_ordering[0] = gp._cell_ordering[0];
     _cell_ordering[1] = gp._cell_ordering[1];
     _cell_ordering[2] = gp._cell_ordering[2];
     _cell_ordering[3] = gp._cell_ordering[3];
     //#ifdef _TRAIL_MPI_
     _comm = gp._comm;
     //#endif
   };

GEM_Partition ( )

inline

Definition at line 444 of file GEM.H.

References _cell_ordering, _comm, _debug, _hexconn, _id, _nc, _nghex, _ngnodes, _ngpris, _ngpyr, _ngtet, _nvface, _out, _prisconn, _pyrconn, and _tetconn.

   {
     _id       = 0;
     _out      = NULL;
     _ngnodes  = 0;
     _ngtet    = 0;
     _nghex    = 0;
     _ngpyr    = 0;
     _ngpris   = 0;
     _nvface   = 0;
     _nc.resize(0);
     _debug    = false;
     _tetconn.resize(0);
     _pyrconn.resize(0);
     _prisconn.resize(0);
     _hexconn.resize(0);
     _cell_ordering[0] = 1;
     _cell_ordering[1] = 2;
     _cell_ordering[2] = 3;
     _cell_ordering[3] = 4;
     //#ifdef _TRAIL_MPI_
     _comm = MPI_COMM_NULL;
     //#endif
   };

GEM_Partition	(	unsigned int	id,
		MPI_Comm	comm = `MPI_COMM_NULL`
	)

inline

Definition at line 469 of file GEM.H.

References _cell_ordering, _debug, _hexconn, _nc, _nghex, _ngnodes, _ngpris, _ngpyr, _ngtet, _nvface, _out, _prisconn, _pyrconn, and _tetconn.

     : _id(id), _comm(comm)
   {
     _out      = NULL;
     _ngnodes  = 0;
     _ngtet    = 0;
     _nghex    = 0;
     _ngpyr    = 0;
     _ngpris   = 0;
     _nvface   = 0;
     _nc.resize(0);
     _debug    = false;
     _tetconn.resize(0);
     _pyrconn.resize(0);
     _prisconn.resize(0);
     _hexconn.resize(0);
     _cell_ordering[0] = 1;
     _cell_ordering[1] = 2;
     _cell_ordering[2] = 3;
     _cell_ordering[3] = 4;
   };

Member Function Documentation

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

Definition at line 1227 of file GEM.C.

References GEM_DomainBoundary::_debug, GEM_DomainBoundary::_id, GEM_DomainBoundary::_ngquad, GEM_DomainBoundary::_ngtri, GEM_DomainBoundary::_nnodes, GEM_DomainBoundary::_out, GEM_DomainBoundary::_quadconn, GEM_DomainBoundary::_triconn, and GEM_DomainBoundary::NNodes().

 {
   assert(ntri >= ngtri && nquad >= ngquad);
   if(_debug && _out)
     *_out << "GEM_Mesh(" << _id << ")::AddDomainBoundary: "
           << "Adding domain boundary with"
           << " id " << db_id << "." << endl;
   GEM_DomainBoundary new_db;
   new_db._id = db_id;
   new_db._ngtri = ngtri;
   new_db._ngquad = ngquad;
   int indy = 0;
   new_db._triconn.resize(3*ntri);
   new_db._quadconn.resize(4*nquad);
   new_db._out = _out;
   new_db._debug = _debug;
   while(indy < 3*ntri){
     assert(tris[indy] != 0);
     new_db._triconn[indy] = tris[indy];
     indy++;
   }
   indy = 0;
   while(indy < 4*nquad){
     assert(quads[indy] != 0);
     new_db._quadconn[indy] = quads[indy];
     indy++;
   }
   new_db._nnodes = new_db.NNodes();
   unsigned int csize = _db.size();
   if(_debug && _out)
     *_out << "GEM_Partition(" << _id << ")::AddDomainBoundary: "
           << "DomainBoundary " << csize << " has (nodes,tri,gtri,quad,gquad)" 
           << " = (" << new_db._nnodes << "," << ntri << "," << ngtri << "," 
           << nquad << "," << ngquad << ")" << std::endl;
   _db.push_back(new_db);
 }

Here is the call graph for this function:

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

Definition at line 1201 of file GEM.C.

References GEM_PartitionBoundary::_debug, GEM_PartitionBoundary::_out, and GEM_PartitionBoundary::populate().

 {
   assert(rpid > 0);
   if(_debug && _out)
     *_out << "GEM_Mesh(" << _id << ")::AddPartitionBoundary: "
           << "Adding Border with"
           << " partition " << rpid << "." << endl;
   GEM_PartitionBoundary new_pb;
   new_pb._out = _out;
   new_pb._debug = _debug;
   if(!validate_comm_list(ncsend,ncrecv,csend,crecv)){
     if(_out)
       *_out << "GEM_Mesh(" << _id << ")::AddPartitionBoundary"
             << ": Validation of "
             << "communication arrays failed, aborting." << endl;
     exit(-1);
   }
   new_pb.populate(rpid,nnshare,nnsend,nnrecv,ncsend,ncrecv,
                   nshared,nsend,nrecv,csend,crecv);
   _pb.push_back(new_pb);
 }

Here is the call graph for this function:

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

Definition at line 1072 of file GEM.C.

 {
   _solver_data._string_data.push_back(wname);
   unsigned int current_size = _solver_data._field_data.size();
   if(current_size == 0)
     _solver_data._field_data.resize(2);
   else{
     std::vector<double> temp;
     _solver_data._field_data.push_back(temp);
     _solver_data._field_data.push_back(temp);
     _solver_data._stride_field.push_back(0);
     _solver_data._stride_field.push_back(0);
   }
   unsigned int ncells = _tetconn.size()/4 + _hexconn.size()/8 +
     _prisconn.size()/6 + _pyrconn.size()/5;
   unsigned int nnodes = _nc.size()/3;
   _solver_data._field_data[current_size].resize(nval_cells*ncells);
   _solver_data._field_data[current_size+1].resize(nval_nodes*nnodes);
   _solver_data._stride_field.resize(2);
   _solver_data._stride_field[current_size] = nval_cells;
   _solver_data._stride_field[current_size+1] = nval_nodes;
   memcpy(&_solver_data._field_data[current_size][0],cell_data,
          sizeof(double)*nval_cells*ncells);
   memcpy(&_solver_data._field_data[current_size+1][0],node_data,
          sizeof(double)*nval_nodes*nnodes);
   return(true);
 }

pair< unsigned int, unsigned int > Cell2Elem ( unsigned int cell )

Definition at line 875 of file GEM.C.

References offset().

Referenced by ResolveCellMapping().

 {
   unsigned int elem_type = 0;
   unsigned int offset = 0;
   unsigned int nreal_elems;
   while(elem_type < 4){
     switch(_cell_ordering[elem_type]){
     case 1:
       nreal_elems = _tetconn.size()/4 - _ngtet;
       if(cell <= (offset+nreal_elems))
         return(make_pair(1,cell-offset));
       else
         offset += nreal_elems;
       break;
     case 2:
       nreal_elems = _pyrconn.size()/5 - _ngpyr;
       if(cell <= (offset+nreal_elems))
         return(make_pair(2,cell-offset));
       else
         offset += nreal_elems;
       break;
     case 3:
       nreal_elems = _prisconn.size()/6 - _ngpris;
       if(cell <= (offset+nreal_elems))
         return(make_pair(3,cell-offset));
       else
         offset += nreal_elems;
       break;
     case 4:
       nreal_elems = _hexconn.size()/8 - _nghex;
       if(cell <= (offset+nreal_elems))
         return(make_pair(4,cell-offset));
       else
         offset += nreal_elems;
       break;
     }
     elem_type++;
   }
   elem_type = 0;
   while(elem_type < 4){
     switch(_cell_ordering[elem_type]){
     case 1:
       nreal_elems = _tetconn.size()/4 - _ngtet;
       if(cell <= (offset+_ngtet))
         return(make_pair(1,cell-offset+nreal_elems));
       else
         offset += _ngtet;
       break;
     case 2:
       nreal_elems = _pyrconn.size()/5 - _ngpyr;
       if(cell <= (offset+_ngpyr))
         return(make_pair(2,cell-offset+nreal_elems));
       else
         offset += _ngpyr;
       break;
     case 3:
       nreal_elems = _prisconn.size()/6 - _ngpris;
       if(cell <= (offset+_ngpris))
         return(make_pair(3,cell-offset+nreal_elems));
       else
         offset += _ngpris;
       break;
     case 4:
       nreal_elems = _hexconn.size()/8 - _nghex;
       if(cell <= (offset+_nghex))
         return(make_pair(4,cell-offset+nreal_elems));
       else
         offset += _nghex;
       break;
     }
     elem_type++;
   }
   if(_out)
     *_out << "GEM_Partition(" << _id 
           << ")::Cell2Elem: Fatal error - Could not find cell " 
           << cell << ", dying.\n";
   exit(1);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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
	)

Definition at line 476 of file GEM.C.

References AddPconnSection(), and i.

 {
   
   unsigned int section_size = 0;
   unsigned int i = 0;
   ng = 0;
   if(index_vectors[i].size() == 0 && _out){
     *_out 
       << "Roccom_create_pconn::Attempt to create empty pconn. Aborting.\n"; 
     exit(1);
   }
   pc.resize(0);
   AddPconnSection(rpids,index_vectors[i++],section_size,pc);
   nreal = section_size;
   while(i < 5 && index_vectors[i].size() != 0){
     section_size = 0;
     AddPconnSection(rpids,index_vectors[i++],section_size,pc);
     ng += section_size;
   }
 }

Here is the call graph for this function:

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

Definition at line 413 of file GEM.C.

References COM_DOUBLE, COM_get_attribute_handle(), COM_new_attribute(), and COM_set_array().

Referenced by TRAIL_FluRegisterVolSoln().

 {
   string aname(volume_window+"."+fname);
   int ahndl = COM_get_attribute_handle(aname);
   if(ahndl<=0)
     COM_new_attribute(aname,'e',COM_DOUBLE,ncomp,unit.c_str());
   if(fvec.size() > 0)
     COM_set_array(aname,pane_id,&fvec[0],ncomp);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool CreatePconn ( const std::string & wname )

Definition at line 710 of file GEM.C.

References GEM_PartitionBoundary::_recvcells, GEM_PartitionBoundary::_recvnodes, GEM_PartitionBoundary::_rpart, GEM_PartitionBoundary::_sendcells, GEM_PartitionBoundary::_sendnodes, GEM_PartitionBoundary::_sharenodes, COM_set_array(), and COM_set_size().

 {
   if(_debug && _out)
     *_out << "GEM_Partition(" << _id << ")::CreatePconn: enter" << endl;
   pconn_nghost = 0;
   unsigned int nrp = _pb.size(); // number of remote partitions
   std::vector<unsigned int> rpid_v; // remote pane id's
   std::vector<std::vector<std::vector<unsigned int> > > indices_v(5);
   rpid_v.resize(nrp);
   indices_v[0].resize(nrp); // shared nodes
   indices_v[1].resize(nrp); // sent nodes
   indices_v[2].resize(nrp); // recv nodes
   indices_v[3].resize(nrp); // send elements
   indices_v[4].resize(nrp); // recv elements
   unsigned int rpin = 0;
   while(rpin < nrp){
     GEM_PartitionBoundary &fb = _pb[rpin];
     unsigned int rpid = fb._rpart * 100 + 1;
     rpid_v[rpin] = rpid;
     indices_v[0][rpin] = fb._sharenodes;
     indices_v[1][rpin] = fb._sendnodes;
     indices_v[2][rpin] = fb._recvnodes;
     indices_v[3][rpin] = fb._sendcells;
     indices_v[4][rpin] = fb._recvcells;
     rpin++;
   }
   unsigned int nreal = 0;
   Create_com_pconn(rpid_v,indices_v,nreal,pconn_nghost,pconn);
   assert(pconn.size() - pconn_nghost  == nreal);
   COM_set_size((wname+".pconn"),pane_id,pconn.size(),pconn_nghost);
   COM_set_array((wname+".pconn"),pane_id,&pconn[0],1);
   if(_debug && _out)
     *_out << "GEM_Partition(" << _id << ")::CreatePconn: exit" << endl;
   return(true);
 }

Here is the call graph for this function:

bool debug ( bool s = true )

Definition at line 1266 of file GEM.C.

References s.

Referenced by main(), and TRAIL_Debug().

 {
   _debug = s;
   if(_debug && _out)
     *_out << "GEM_Partition(" << _id << ")::Debugging turned on\n";
   return(_debug);
 }

Here is the caller graph for this function:

bool DestroyWindows ( )

Definition at line 584 of file GEM.C.

References COM_delete_window().

Referenced by main(), and TRAIL_RemeshWrite().

 {
   if(volume_window.empty() || surface_window.empty())
     return(false);
   COM_delete_window(volume_window);
   COM_delete_window(surface_window);
   //  volume_window.erase();
   //  surface_window.erase();
   return(true);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 956 of file GEM.C.

References offset().

Referenced by PartitionBoundary::populate_local_arrays(), TRAIL_FluWriteCMP(), and TRAIL_GeoPartReadPartitionBoundaryASCII().

 {
   unsigned int elem_type = 0;
   unsigned int offset = 0;
   unsigned int nreal_elem;
   while(elem_type < 4){
     switch(_cell_ordering[elem_type]){
     case 1:
       nreal_elem = _tetconn.size()/4 - _ngtet;
       if(ti.first != 1 || ti.second > nreal_elem)
         offset += nreal_elem;
       else{
         return(offset+ti.second);
       }
       break;
     case 2:
       nreal_elem = _pyrconn.size()/5 - _ngpyr;
       if(ti.first != 2 || ti.second > nreal_elem)
         offset += nreal_elem;
       else{
         return(offset+ti.second);
       }
       break;
     case 3:
       nreal_elem = _prisconn.size()/6 - _ngpris;
       if(ti.first != 3 || ti.second > nreal_elem)
         offset += nreal_elem;
       else{
         return(offset+ti.second);
       }
       break;
     case 4:
       nreal_elem = _hexconn.size()/8 - _nghex;
       if(ti.first != 4 || ti.second > nreal_elem)
         offset += nreal_elem;
       else{
         return(offset+ti.second);
       }
       break;
     }
     elem_type++;
   }
   elem_type = 0;
   while(elem_type < 4){
     switch(_cell_ordering[elem_type]){
     case 1:
       nreal_elem = _tetconn.size()/4 - _ngtet;
       if(ti.first != 1)
         offset += _ngtet;
       else{
         return(offset+ti.second-nreal_elem);
       }
       break;
     case 2:
       nreal_elem = _pyrconn.size()/5 - _ngpyr;
       if(ti.first != 2)
         offset += _ngpyr;
       else{
         return(offset+ti.second-nreal_elem);
       }
       break;
     case 3:
       nreal_elem = _prisconn.size()/6 - _ngpris;
       if(ti.first != 3)
         offset += _ngpris;
       else{
         return(offset+ti.second-nreal_elem);
       }
       break;
     case 4:
       nreal_elem = _hexconn.size()/8 - _nghex;
       if(ti.first != 4)
         offset += _nghex;
       else{
         return(offset+ti.second-nreal_elem);
       }
       break;
     }
     elem_type++;
   }
   if(_out)
     *_out << "GEM_Partition(" << _id 
           << ")::Elem2Cell: Fatal error.  Could not find element "
           << "(" << ti.first << "," << ti.second << "). Dying.\n";
   exit(1);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool InitRoccomWindows ( const std::string & wname )

Definition at line 685 of file GEM.C.

References COM_new_window().

Referenced by main(), and TRAIL_RemeshWrite().

 {
   if(_debug && _out)
     *_out << "GEM_Partition(" << _id 
           << ")::InitRoccomWindows: Creating windows" << endl;
   volume_window = wname+"_vol";
   surface_window = wname+"_surf";
   COM_new_window(volume_window);
   COM_new_window(surface_window);
   if(_debug && _out)
     *_out << "GEM_Partition(" << _id 
           << ")::InitRoccomWindows: Populate Volume Window" 
           << endl;
   if(!PopulateVolumeWindow(volume_window))
     return(false);
   if(_debug && _out)
     *_out << "GEM_Partition(" << _id 
           << ")::InitRoccomWindows: Populate Surface Window" 
           << endl;
   if(!PopulateSurfaceWindow(surface_window))
     return(false);
   return(true);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 1385 of file GEM.C.

References GEM_DomainBoundary::_id, GEM_DomainBoundary::_ngquad, GEM_DomainBoundary::_ngtri, GEM_DomainBoundary::_out, GEM_DomainBoundary::_quadconn, GEM_DomainBoundary::_triconn, and GEM_DomainBoundary::debug().

Referenced by FluRegion::PopulateFluPatches(), and TRAIL_FluPopulatePatches().

 {
   std::vector<GEM_DomainBoundary> indb(_db);
   std::vector<GEM_DomainBoundary> &outdb = _db;
   // Determine how many unique target BC's we have on this 
   // source DB.
   list<unsigned int> local_patches;
   unsigned int partpatch = 0;
   unsigned int npartpatch = indb.size();
   while(partpatch < npartpatch)
     local_patches.push_back(bcmap[indb[partpatch++]._id]);
   local_patches.sort();
   local_patches.unique();
   unsigned int nlocal_patches = local_patches.size();
   if(_debug && _out){
     *_out << "GEM_Partition(" << _id 
           << ")::MapDomainBoundaries: Local patches: " << endl
           << "GEM_Partition(" << _id << ")::MapDomainBoundaries: ";
     list<unsigned int>::iterator pli = local_patches.begin();
     while(pli != local_patches.end())
       *_out << *pli++ << " ";
     *_out << endl;
   }
   // resize the storage for the local db's to the number of unique 
   // bc types on this partition
   outdb.resize(nlocal_patches);
   std::vector< list<unsigned int> > ppatch_list;
   ppatch_list.resize(nlocal_patches);
   
   // For every bc type on the source db, assign the target bc type to the 
   // local storage array.  Also construct an index mapping so we
   // can map bctype ----> local_patch_storage_array_index
   unsigned int local_patch = 0;
   list<unsigned int>::iterator li = local_patches.begin();
   while(li != local_patches.end()){  
     GEM_DomainBoundary &fp = outdb[local_patch];
     fp._id     = *li;
     fp._ngtri  = 0;
     fp._ngquad = 0;
     if(_debug) 
       fp.debug();
     unsigned int local_tri_size = 0;
     unsigned int local_quad_size = 0;
     // Now - loop through every source bc and find out which ones 
     // contribute to this particular target bc so we can determine the total
     // size of the connectivities for pre-allocation.
     partpatch = 0;
     while(partpatch < npartpatch){
       const GEM_DomainBoundary &pp = indb[partpatch];
       unsigned int ggbpid = pp._id;
       unsigned int tdbid = bcmap[ggbpid];
       if(tdbid == *li){
         local_tri_size  += pp._triconn.size()/3;
         fp._ngtri  += pp._ngtri;
         local_quad_size  += pp._quadconn.size()/4;
         fp._ngquad += pp._ngquad;
         ppatch_list[local_patch].push_back(partpatch);
       }
       partpatch++;
     }
     fp._triconn.resize(3*local_tri_size);
     fp._quadconn.resize(4*local_quad_size);
     li++;
     local_patch++;
   }
   
   // Step through all the target db's and check the list that tells us
   // which source db's to get our surface element connectivities from.
   // This is the second pass to actually populate the connectivities. 
   local_patch = 0;
   while(local_patch < nlocal_patches){
     GEM_DomainBoundary &fp = outdb[local_patch];
     fp._out = indb[0]._out;
     unsigned int tri       = 0;
     unsigned int gtri      = 0;
     unsigned int quad      = 0;
     unsigned int gquad     = 0;
     unsigned int realtri   = fp._triconn.size()/3 - fp._ngtri;
     unsigned int realquads = fp._quadconn.size()/4 - fp._ngquad;
     li = ppatch_list[local_patch].begin();
     while(li != ppatch_list[local_patch].end()){
       const GEM_DomainBoundary &pp = indb[*li++];
       unsigned int pptri = 0;
       unsigned int ppquad = 0;
       unsigned int ntri = pp._triconn.size()/3;
       unsigned int nrealtri = ntri - pp._ngtri;
       unsigned int nquad = pp._quadconn.size()/4;
       unsigned int nrealquad = nquad - pp._ngquad;
       while(ppquad < nquad){
         if(ppquad < nrealquad){
           fp._quadconn[4*quad]   = pp._quadconn[4*ppquad];
           fp._quadconn[4*quad+1] = pp._quadconn[4*ppquad+1];
           fp._quadconn[4*quad+2] = pp._quadconn[4*ppquad+2];
           fp._quadconn[4*quad+3] = pp._quadconn[4*ppquad+3];
           quad++;
           ppquad++;
         }
         else{
           fp._quadconn[(4*realquads)+(4*gquad)]   = pp._quadconn[4*ppquad];
           fp._quadconn[(4*realquads)+(4*gquad)+1] = pp._quadconn[4*ppquad+1];
           fp._quadconn[(4*realquads)+(4*gquad)+2] = pp._quadconn[4*ppquad+2];
           fp._quadconn[(4*realquads)+(4*gquad)+3] = pp._quadconn[4*ppquad+3];
           gquad++;
           ppquad++;
         }
       }
       while(pptri < ntri){
         if(pptri < nrealtri){
           fp._triconn[3*tri]   = pp._triconn[3*pptri];
           fp._triconn[3*tri+1] = pp._triconn[3*pptri+1];
           fp._triconn[3*tri+2] = pp._triconn[3*pptri+2];
           tri++;
           pptri++;
         }
         else{
           fp._triconn[(3*realtri)+(3*gtri)]   = pp._triconn[3*pptri];
           fp._triconn[(3*realtri)+(3*gtri)+1] = pp._triconn[3*pptri+1];
           fp._triconn[(3*realtri)+(3*gtri)+2] = pp._triconn[3*pptri+2];
           gtri++;
           pptri++;
         }
       }
     }
     local_patch++;
   }
   return;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

unsigned int nelem ( )

inline

Definition at line 366 of file GEM.H.

References _hexconn, _prisconn, _pyrconn, and _tetconn.

   {
     return(_tetconn.size()/4+_pyrconn.size()/5+
            _prisconn.size()/6+_hexconn.size()/8);
   };

GEM_Partition& operator= ( const GEM_Partition & gp )

inline

Definition at line 491 of file GEM.H.

References _cell_ordering, _comm, _debug, _hexconn, _id, _nc, _nghex, _ngnodes, _ngpris, _ngpyr, _ngtet, _nvface, _out, _prisconn, _pyrconn, and _tetconn.

   {
     _id       = gp._id;
     _out      = gp._out;
     _ngnodes  = gp._ngnodes;
     _ngtet    = gp._ngtet;
     _nghex    = gp._nghex;
     _ngpyr    = gp._ngpyr;
     _ngpris   = gp._ngpris;
     _nc       = gp._nc;
     _nvface   = gp._nvface;
     _tetconn  = gp._tetconn;
     _pyrconn  = gp._pyrconn;
     _prisconn = gp._prisconn;
     _hexconn  = gp._hexconn;
     _debug    = gp._debug;
     //#ifdef _TRAIL_MPI_
     _comm     = gp._comm;
     //#endif
     _cell_ordering[0] = gp._cell_ordering[0];
     _cell_ordering[1] = gp._cell_ordering[1];
     _cell_ordering[2] = gp._cell_ordering[2];
     _cell_ordering[3] = gp._cell_ordering[3];
     return(*this);
   };

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

Definition at line 1358 of file GEM.C.

 {
   unsigned int nborders = pb.size();
   _pb.resize(nborders);
   //    if(_solver_data._int_data.empty())
   //      _solver_data._int_data.resize(2);
   //    _solver_data._int_data[0].resize(nborders);
   unsigned int border = 0;
   while(border < nborders){
     _pb[border]._rpart      = pb[border]._rpart;
     _pb[border]._sendcells  = pb[border]._sendcells;
     _pb[border]._recvcells  = pb[border]._recvcells;
     _pb[border]._sharenodes = pb[border]._sharenodes;
     _pb[border]._sendnodes  = pb[border]._sendnodes;
     _pb[border]._recvnodes  = pb[border]._recvnodes;
     //      _pb[border]._rbid       = pb[border]._rbid;
     _pb[border]._out        = pb[border]._out;
     border++;
   }
   return(true);
 }

bool PopulateSurfaceWindow ( const std::string & wname )

Definition at line 819 of file GEM.C.

References GEM_DomainBoundary::pane_id, GEM_DomainBoundary::PopulateSurfaceArrays(), and GEM_DomainBoundary::Register_com_surfmesh().

 {
   if(_debug && _out)
     *_out << "GEM_Partition(" << _id 
           << ")::PopulateSurfaceWindow: enter" << endl;
   // For each domain boundary
   int npatches = _db.size();
   int patch = 0;
   while(patch < npatches){
     GEM_DomainBoundary &fp = _db[patch];
     fp.pane_id = _id * 100 + (patch+1) + 1;
     fp.PopulateSurfaceArrays(_nc,_ngnodes);
     fp.Register_com_surfmesh(wname);
     patch++;
   }
   if(_debug && _out)
     *_out << "GEM_Partition(" << _id 
           << ")::PopulateSurfaceWindow: exit" << endl;
   return(true);
 }

Here is the call graph for this function:

bool PopulateVolumeWindow ( const std::string & wname )

Definition at line 747 of file GEM.C.

References COM_set_array(), and COM_set_size().

Referenced by TRAIL_RocmopSmooth().

 {
   if(_debug && _out)
     *_out << "GEM_Partition(" << _id 
           << ")::PopulateVolumeWindow: enter" << endl;
   pane_id = _id * 100 + 1; 
   // Set the volume mesh entity sizes and register the arrays
   unsigned int nnodes = _nc.size()/3;
   COM_set_size((wname+".nc"),pane_id,nnodes,_ngnodes);
   COM_set_array((wname+".nc"),pane_id,&_nc[0],3);
   unsigned int el_type = 0;
   while(el_type < 4){
     unsigned int nreal;
     switch(_cell_ordering[el_type]){
     case 1:
       nreal = _tetconn.size()/4 - _ngtet;
       if(nreal > 0)
         Register_com_volconn(wname,pane_id,nreal,_ngtet,_tetconn,4,false);
       break;
     case 2:
       nreal = _pyrconn.size()/5 - _ngpyr;
       if(nreal > 0)
         Register_com_volconn(wname,pane_id,nreal,_ngpyr,_pyrconn,5,false);
       break;
     case 3:
       nreal = _prisconn.size()/6 - _ngpris;
       if(nreal > 0)
         Register_com_volconn(wname,pane_id,nreal,_ngpris,_prisconn,6,false);
       break;
     case 4:
       nreal = _hexconn.size()/8 - _nghex;
       if(nreal > 0)
         Register_com_volconn(wname,pane_id,nreal,_nghex,_hexconn,8,false);
       break;
     }
     el_type++;
   }
   el_type = 0;
   while(el_type < 4){
     unsigned int nreal;
     switch(_cell_ordering[el_type]){
     case 1:
       nreal = _tetconn.size()/4 - _ngtet;
       if(_ngtet > 0)
         Register_com_volconn(wname,pane_id,_ngtet,_ngtet,_tetconn,4,true);
       break;
     case 2:
       nreal = _pyrconn.size()/5 - _ngpyr;
       if(_ngpyr > 0)
         Register_com_volconn(wname,pane_id,_ngpyr,_ngpyr,_pyrconn,5,true);
       break;
     case 3:
       nreal = _prisconn.size()/6 - _ngpris;
       if(_ngpris > 0)
         Register_com_volconn(wname,pane_id,_ngpris,_ngpris,_prisconn,6,true);
       break;
     case 4:
       nreal = _hexconn.size()/8 - _nghex;
       if(_nghex > 0)
         Register_com_volconn(wname,pane_id,_nghex,_nghex,_hexconn,8,true);
       break;
     }
     el_type++;
   }
   CreatePconn(wname);
   if(_debug && _out)
     *_out << "GEM_Partition(" << _id 
           << ")::PopulateVolumeWindow: exit" << endl;
   return(true);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 595 of file GEM.C.

 {
   return(false);
 }

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`
	)

Definition at line 503 of file GEM.C.

References COM_set_array(), and COM_set_size().

 {
   if(nel == 0 || esize == 0) return;
   unsigned int nreal = conn.size()/esize - ngel;
   string mesh_type;
   switch(esize){
   case 4: // Tets
     mesh_type = ":T4";
     break;
   case 5:
     mesh_type = ":P5";
     break;
   case 6:
     mesh_type = ":P6";
     break;
   case 8:
     mesh_type = ":H8";
     break;
   default:
     if(_out)
       *_out << "Roccom_register_mesh::Error: Unknown mesh type, aborting.\n"; 
     exit(1);
   }
   mesh_type = wname + "." + mesh_type + ":";
   string entity;
   if(nreal > 0 && !ghost_part){
     entity = mesh_type + "real";
     COM_set_size(entity,paneid,nreal);
     COM_set_array(entity,paneid,&(conn[0]),esize);
   }
   if(ngel > 0 && ghost_part){
     entity = mesh_type + "virtual";
     COM_set_size(entity,paneid,ngel,ngel);
     COM_set_array(entity,paneid,&(conn[nreal*esize]),esize);
   } 
 }

Here is the call graph for this function:

void report ( )

Definition at line 49 of file GEM.C.

Referenced by main().

 {
   if(_out){
     *_out  << "GEM_Partition ID: " << _id << endl
            << "Mesh Entities: Total Real Ghosts" << endl
            << "Number of Nodes:    (" << _nc.size()/3 << "," 
            << _nc.size()/3 - _ngnodes << "," << _ngnodes << ")" 
            << endl
            << "Number of Elements: (" << nelem() << ","
            << nelem() - _ngtet - _ngpyr - _ngpris - _nghex << ","
            << _ngtet + _ngpyr + _ngpris + _nghex << ")" << endl
            << "Cell Mapping: (" << _cell_ordering[0] << "," 
            << _cell_ordering[1] << "," << _cell_ordering[2] << ","
            << _cell_ordering[3] << ")" << endl;
     if(_tetconn.size() > 0) 
       *_out << "Tets:     (" << _tetconn.size()/4  << "," 
             << _tetconn.size()/4 - _ngtet << "," << _ngtet  << ")" << endl;
     if(_pyrconn.size() > 0)
       *_out << "Pyramids: (" << _pyrconn.size()/5  << "," 
             << _pyrconn.size()/5 - _ngpyr << "," << _ngpyr  << ")" << endl;
     if(_prisconn.size() > 0)
       *_out   << "Prisms:   (" << _prisconn.size()/6 << "," 
               << _prisconn.size()/6 - _ngpris << "," << _ngpris << ")" << endl;
     if(_hexconn.size() > 0)
       *_out   << "Hexes:    (" << _hexconn.size()/8  << "," 
               << _hexconn.size()/8 - _nghex << "," << _nghex  << ")" << endl;
     if(_debug){
       debug(false);
       *_out << "Cell debugging: " << endl;
       unsigned int nel,el;
       unsigned int nlin = 5;
       if(_tetconn.size() > 0) {
         *_out << "Tet Cell IDs: " << endl;
         nel = _tetconn.size()/4;
         nlin = 5;
         el = 0;
         while(el < nel){
           *_out << setw(12) << Elem2Cell(std::make_pair((unsigned int)1,++el));
           if(!(el%nlin))
             *_out << endl;
         }
         if(el%nlin) *_out << endl;
       }
       if(_pyrconn.size() > 0){
         *_out << "Pyr Cell IDs: " << endl;
         nel = _pyrconn.size()/5;
         el = 0;
         while(el < nel){
           *_out << setw(12) << Elem2Cell(std::make_pair((unsigned int)2,++el));
           if(!(el%nlin))
             *_out << endl;
         }
         if(el%nlin) *_out << endl;
       }
       if(_prisconn.size() > 0){
         *_out << "Pris Cell IDs:" << endl;
         nel = _prisconn.size()/6;
         el = 0;
         while(el < nel){
           *_out << setw(12) << Elem2Cell(std::make_pair((unsigned int)3,++el));
           if(!(el%nlin))
             *_out << endl;
         }
         if(el%nlin) *_out << endl;
       }
       if(_hexconn.size() > 0){
         *_out << "Hex Cell IDs: " << endl;
         nel = _hexconn.size()/8;
         el = 0;
         while(el < nel){
           *_out << setw(12) << Elem2Cell(std::make_pair((unsigned int)4,++el));
           if(!(el%nlin))
             *_out << endl;
         }
         if(el%nlin) *_out << endl;
       }
       debug(true);
     }
   }
 }

Here is the caller graph for this function:

void report_domain_boundaries ( )

Definition at line 163 of file GEM.C.

References GEM_DomainBoundary::report().

 {
   if(_out){
     *_out << "==================================================" << endl  
           << "Number of Domain Boundaries: " << _db.size() << endl;
     unsigned int patch = 0;
     while(patch < _db.size()){
       GEM_DomainBoundary &fp = _db[patch++];
       *_out << "------------------------------------------------" << endl;
       fp.report();
       *_out << "------------------------------------------------" << endl;
     }
     *_out << "==================================================" << endl;  
   }
 }

Here is the call graph for this function:

void report_partition_boundaries ( )

Definition at line 131 of file GEM.C.

References GEM_PartitionBoundary::report().

 {
   if(_out){
     *_out << "==================================================" << endl  
           << "Number of partition boundaries: " << _pb.size() << endl; 
     unsigned int border = 0;
     while(border < _pb.size()){
       GEM_PartitionBoundary &fb = _pb[border++];
       *_out << "------------------------------------------------" << endl  
             << " Partition Boundary #" << border+1 << endl;
       fb.report();
       *_out << "------------------------------------------------" << endl;
     }
     *_out << "==================================================" << endl;
   }
 }

Here is the call graph for this function:

void ResolveCellMapping ( GEM_Partition & sp )

Definition at line 1524 of file GEM.C.

References GEM_PartitionBoundary::_recvcells, GEM_PartitionBoundary::_sendcells, and Cell2Elem().

 {
   if(_debug && _out)
     *_out << "GEM_Partition::ResolveCellMapping: enter";
   unsigned int npb = _pb.size();
   unsigned int p = 0;
   while(p < npb){
     GEM_PartitionBoundary &pbi = _pb[p++];
     unsigned int nsend = pbi._sendcells.size();
     unsigned int cell = 0;
     while(cell < nsend){
       pbi._sendcells[cell] = Elem2Cell(sp.Cell2Elem(pbi._sendcells[cell]));
       cell++;
     }
     unsigned int nrecv = pbi._recvcells.size();
     cell = 0;
     while(cell < nrecv){
       pbi._recvcells[cell] = Elem2Cell(sp.Cell2Elem(pbi._recvcells[cell]));
       cell++;
     }
   }
   if(_debug && _out)
     *_out << "GEM_Partition(" << _id << ")::ResolveCellMapping: exit";
 } 

Here is the call graph for this function:

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

Definition at line 1276 of file GEM.C.

 {
   if(_debug && _out){
     ostringstream Ostr;
     Ostr << "GEM_Partition(" << _id << ")::SetNodalCoordinates "
          << " total nodes = " << nn << ", " << ng << " ghosts.\n";
     *_out << Ostr.str();
   }
   assert(nn >= ng);
   _ngnodes = ng;
   _nc.resize(3*nn);
   memcpy((void *)&_nc[0],(void *)data,3*nn*sizeof(double));
 }

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

Definition at line 1045 of file GEM.C.

 {
   _solver_data._string_data.push_back(wname);
   _solver_data._field_data.resize(2);
   unsigned int ncells = _tetconn.size()/4 + _hexconn.size()/8 +
     _prisconn.size()/6 + _pyrconn.size()/5;
   unsigned int nnodes = _nc.size()/3;
   if(_debug && _out)
     *_out << "GEM_Partition(" << _id << ")::SetSolverDataBlock: "
           << "Receiving data for " << nval_cells << " doubles on " << ncells 
           << " cells and " << nval_nodes <<  " doubles on " << nnodes 
           << " nodes." << std::endl; 
   _solver_data._field_data[0].resize(nval_cells*ncells);
   _solver_data._field_data[1].resize(nval_nodes*nnodes);
   _solver_data._stride_field.resize(2);
   _solver_data._stride_field[0] = nval_cells;
   _solver_data._stride_field[1] = nval_nodes;
   memcpy(&_solver_data._field_data[0][0],cell_data,
          sizeof(double)*nval_cells*ncells);
   memcpy(&_solver_data._field_data[1][0],node_data,
          sizeof(double)*nval_nodes*nnodes);
   return(true);
 }

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

Definition at line 1291 of file GEM.C.

 {
   if(_debug && _out){
     *_out << "GEM_Partition(" << _id << ")::SetVolumeElements "
           << " total cells = " << ncells << " of size " << npe
           << " of which " << ng << " are ghosts." << endl;
   }
   unsigned int datasize = ncells*npe*sizeof(int);
   assert(ncells >= ng);
   int ndatp = npe*ncells;
   for(int ndat =0;ndat < ndatp;ndat++)
     assert(data[ndat] != 0);
   void *dest;
   switch(npe){
   case 4:
     _tetconn.resize(4*ncells);
     dest = &_tetconn[0];
     _ngtet = ng;
     break;
   case 5:
     _pyrconn.resize(5*ncells);
     dest = &_pyrconn[0];
     _ngpyr = ng;
     break;
   case 6:
     _prisconn.resize(6*ncells);
     dest = &_prisconn[0];
     _ngpris = ng;
     break;
   case 8:
     _hexconn.resize(8*ncells);
     dest = &_hexconn[0];
     _nghex = ng;
     break;
   default:
     if(_out)
       *_out << "GEM_Partition::Unknown volume element type.  Aborting." 
             << endl;
     exit(1);
   }
   memcpy(dest,data,datasize);
 }

bool validate_comm_list	(	int	ncsend,
		int	ncrecv,
		int *	csend,
		int *	crecv
	)

Definition at line 1149 of file GEM.C.

 {
   int index = 0;
   int nreal_cell = _tetconn.size()/4 + _prisconn.size()/6 +
     _pyrconn.size()/5 + _hexconn.size()/8 - (_ngtet + _ngpris +
                                              _ngpyr + _nghex);
   bool rval = true;
   while(index < ncsend){
     int ind = index++;
     if(!(csend[ind] <= nreal_cell)){
       if(_out)
         *_out << "SEND CELL " << index << " is a ghost cell!!" << endl;
       rval = false;
     }
     if(!(csend[ind] > 0)){
       if(_out)
         *_out << "SEND CELL " << index << " is zero or negative!" << endl;
       rval = false;
     }
   }
   index = 0;
   list<int> recvcell_list;
   while(index < ncrecv) {
     int ind = index++;
     if(!(crecv[ind] > nreal_cell)){
       if(_out)
         *_out << "RECV CELL " << index << " is a real cell!!" << endl;
       rval = false;
     }
     if(!(crecv[ind] > 0)){
       if(_out)
         *_out << "RECV CELL " << index << " is zero or negative!" << endl;
       rval = false;
     }
     bool duped = false;
     list<int>::iterator rci = recvcell_list.begin();
     while(rci != recvcell_list.end() && !duped){
       if(crecv[ind] == *rci++){
         if(_out)
           *_out << "RECV CELL " << index 
                 << " is duplicated in the receive list!" 
                 << endl;
         duped = true;
       }
     }
     if(!duped)
       recvcell_list.push_back(crecv[ind]);
   }
   return(rval);
 }

bool ValidateMesh ( )

bool WindowInitDone ( )

Definition at line 575 of file GEM.C.

References COM_window_init_done().

Referenced by main(), and TRAIL_RemeshWrite().

 {
   if(volume_window.empty() || surface_window.empty())
     return(false);
   COM_window_init_done(volume_window);
   COM_window_init_done(surface_window);
   return(true);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 601 of file GEM.C.

References TRAIL_CWD(), and TRAIL_WriteWindow().

Referenced by main(), and TRAIL_RemeshWrite().

 {
   string pre(prefix);
   if(pre.empty())
     pre = ".";
   if(volume_window.empty() || surface_window.empty())
     return false;
   if(_debug && _out)
     *_out << "GEM_Partition(" << _id << ")::WriteRocstar: Writing volume window"
           << " in " << prefix << ". CWD = " << TRAIL_CWD() << std::endl;
   if(!TRAIL_WriteWindow(volume_window,pre,volume_window,pre,t,_id,_comm))
     return false;
 //   COM_LOAD_MODULE_STATIC_DYNAMIC(Rocout,"Rocout");
 //   int OUT_set_option = COM_get_function_handle( "Rocout.set_option");
 //   string rankstr("0");
 //   COM_call_function( OUT_set_option, "rankwidth", rankstr.c_str());
   
 //   // Build a filename and write the volume window
 //   string timestring(TRAIL_TimeString(t));
 //   ostringstream Ostr;
 //   Ostr << pre << "/" << volume_window << "_"
 //        << timestring << "_" << setw(5) << setfill('0')
 //        << _id;
 //   int whand = COM_get_function_handle("Rocout.write_attribute");
 //   int all = COM_get_attribute_handle((volume_window+".all"));
 //   if(_debug && _out)
 //     *_out << "GEM_Partition(" << _id 
 //        << ")::WriteRocstar: Writing volume window\n";
 //   COM_call_function(whand,Ostr.str().c_str(),&all,volume_window.c_str(),
 //                  timestring.c_str());
 //   // Write Rocin control file
 //   std::vector<int> pane_ids;
 //   string controlfilename;
 //   COM_get_panes(volume_window.c_str(),pane_ids);
 //   ofstream Ouf;
 //   controlfilename = Ostr.str() + "_in.txt";
 //   Ouf.open(controlfilename.c_str());
 //   Ouf << "@Proc: " << _id - 1 << endl
 //       << "@Files: " << volume_window << "_" << timestring << "_" 
 //       << setw(5) << setfill('0') << _id << ".hdf" << endl;
 //   Ouf.clear();
 //   Ouf << "@Panes: " << pane_ids[0] << endl;
 //   Ouf.close();
 
 //   Ostr.clear();
 //   pane_ids.resize(0);
 //   Ostr.str("");
 //   Ostr << pre << "/" << surface_window << "_"
 //        << timestring << "_" << setw(5) << setfill('0')
 //        << _id;
   if(_debug && _out)
     *_out << "GEM_Partition(" << _id  
           << ")::WriteRocstar: Writing surface window\n";
   if(!TRAIL_WriteWindow(surface_window,pre,surface_window,pre,t,_id,_comm))
     return false;
 //   all = COM_get_attribute_handle((surface_window+".all"));
 //   COM_call_function(whand,Ostr.str().c_str(),&all,surface_window.c_str(),
 //                  timestring.c_str());
 //   // Write Rocin control file
 //   controlfilename = Ostr.str() + "_in.txt";
 //   COM_get_panes(surface_window.c_str(),pane_ids);
 //   Ouf.open(controlfilename.c_str());
 //   Ouf << "@Proc: " << _id - 1 << endl
 //       << "@Files: " << surface_window << "_" << timestring << "_" 
 //       << setw(5) << setfill('0') << _id << ".hdf" << endl;
 //   Ouf.clear();
 //   Ouf << "@Panes: ";
 //   std::vector<int>::iterator pii = pane_ids.begin();
 //   while(pii != pane_ids.end())
 //     Ouf << *pii++ << " ";
 //   Ouf << endl;
 //   Ouf.close();
 //   if(_debug && _out)
 //     *_out << "GEM_Partition(" << _id << ")::WriteRocstar: Unloading Rocout\n";
 //   COM_UNLOAD_MODULE_STATIC_DYNAMIC(Rocout,"Rocout");
   
   return(true);
 }