#include <GEM.H>

Inheritance diagram for GEM_DomainBoundary:

Collaboration diagram for GEM_DomainBoundary:

Public Member Functions
unsigned int	NNodes (void)

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

	GEM_DomainBoundary (const GEM_DomainBoundary &db)

	GEM_DomainBoundary ()

GEM_DomainBoundary &	operator= (const GEM_DomainBoundary &db)

bool	debug (bool s=true)

void	report ()

void	PopulateSurfaceArrays (const std::vector< double > &, unsigned int)

bool	Register_com_surfmesh (const std::string &wname)

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

Public Attributes
unsigned int	_id

unsigned int	_ngtri

unsigned int	_ngquad

unsigned int	_nnodes

std::vector< unsigned int >	_triconn

std::vector< unsigned int >	_quadconn

std::vector< double >	surface_coordinates

unsigned int	surface_ngnodes

std::vector< unsigned int >	surface_tri

std::vector< unsigned int >	surface_quad

GEM_UserData	_data

GEM_UserData	_solver_data

bool	_debug

std::ostream *	_out

int	pane_id

Detailed Description

Definition at line 125 of file GEM.H.

Constructor & Destructor Documentation

GEM_DomainBoundary ( const GEM_DomainBoundary & db )

inline

Definition at line 152 of file GEM.H.

References _data, _debug, _id, _ngquad, _ngtri, _nnodes, _out, _quadconn, and _triconn.

   {
     _id       = db._id;
     _out      = db._out;
     _ngtri    = db._ngtri;
     _ngquad   = db._ngquad;
     _triconn  = db._triconn;
     _quadconn = db._quadconn;
     _debug    = db._debug;
     _data     = db._data;
     _nnodes   = db._nnodes;
   };

GEM_DomainBoundary ( )

inline

Definition at line 164 of file GEM.H.

References _debug, _id, _ngquad, _ngtri, _nnodes, _out, _quadconn, _triconn, and surface_coordinates.

   {
     _id = 0;
     _out = NULL;
     _ngtri = 0;
     _ngquad = 0;
     _triconn.resize(0);
     _quadconn.resize(0);
     _nnodes = 0;
     //    _data.resize(0);
     _debug = false;
     surface_coordinates.resize(0);
   };

Member Function Documentation

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

Definition at line 426 of file GEM.C.

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

Referenced by TRAIL_FluRegisterSurfSoln().

 {
   string aname(wname+"."+fname);
   int ahndl = COM_get_attribute_handle(aname);
   if(!ahndl)
     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 debug ( bool s = true )

inline

Definition at line 193 of file GEM.H.

References _debug, and s.

Referenced by a_d_tensors(), GEM_Partition::MapDomainBoundaries(), rocfracmain::rocfracsoln(), and writetecplotbinary().

   {
     _debug = s;
     return(_debug);
   };

Here is the caller graph for this function:

unsigned int NNodes ( void )

Definition at line 1103 of file GEM.C.

Referenced by GEM_Partition::AddDomainBoundary(), TRAIL_FluResizeSurfSoln(), and TRAIL_RemeshInitFluSurfData().

 {
   if(_nnodes <= 0){
     list<unsigned int> snlist;
     vector<unsigned int>::iterator ci = _triconn.begin();
     while(ci != _triconn.end())
       snlist.push_back(*ci++);
     ci = _quadconn.begin();
     while(ci != _quadconn.end())
       snlist.push_back(*ci++);
     snlist.sort();
     snlist.unique();
     _nnodes = snlist.size();
   }
   return(_nnodes);
 }

Here is the caller graph for this function:

GEM_DomainBoundary& operator= ( const GEM_DomainBoundary & db )

inline

Definition at line 177 of file GEM.H.

References _data, _debug, _id, _ngquad, _ngtri, _nnodes, _out, _quadconn, _triconn, surface_coordinates, surface_quad, and surface_tri.

   {
     _id       = db._id;
     _out      = db._out;
     _ngtri    = db._ngtri;
     _ngquad   = db._ngquad;
     _triconn  = db._triconn;
     _quadconn = db._quadconn;
     _data     = db._data;
     _debug    = db._debug;
     _nnodes   = db._nnodes;
     surface_coordinates = db.surface_coordinates;
     surface_tri = db.surface_tri;
     surface_quad = db.surface_quad;
     return(*this);
   };

void PopulateSurfaceArrays	(	const std::vector< double > &	ic,
		unsigned int	ngnodes
	)

Definition at line 233 of file GEM.C.

Referenced by GEM_Partition::PopulateSurfaceWindow().

 {
   if(_debug && _out)
     *_out  <<"GEM_DomainBoundary::PopulateSurfaceArrays(" << _id 
            << "): Enter\n";
   map<unsigned int,unsigned int> s2v_imap; // idex map surface NC to volume NC 
   list<unsigned int> nodelist;
   std::vector<unsigned int>::iterator ci = _triconn.begin();
   unsigned int indy = 0;
   while(ci != _triconn.end()){
     if(*ci == 0){
       if(_out)
         *_out << "GEM_DomainBoundary::PopulateSurfaceArrays: Error: Found 0 in"
               << " triangle conn. for boundary_id = " << _id  << "\n"
               << " triangle/node (" << indy/3 << "," << (indy-((indy/3)*3)+1) 
               << ")\n"
               << " Number of total triangles = " << _triconn.size()/3 << "\n"
               << " Number of ghost tri       = " << _ngtri << "\n";
       exit(1);
     }
     nodelist.push_back(*ci++);
     indy++;
   }
   ci = _quadconn.begin();
   while(ci != _quadconn.end()){
     assert(*ci != 0);
     nodelist.push_back(*ci++);
   }
   if(_debug && _out)
     *_out  << "GEM_DomainBoundary::PopulateSurfaceArrays(" << _id << "): "
            << "nnodes before sort/unique: " << nodelist.size() << "\n";
   nodelist.sort();
   nodelist.unique();
   if(_debug && _out)
     *_out  << "GEM_DomainBoundary::PopulateSurfaceArrays)" << _id << "): "
            << "nnodes after sort/unique: " << nodelist.size() << "\n";
 
   unsigned int nreal_volume_nodes = ic.size()/3 - ngnodes;
   unsigned int nreal_tris = _triconn.size()/3 - _ngtri;
   unsigned int nreal_quads = _quadconn.size()/3 - _ngquad;
   // Run a debugging check on the surface nodes
   if(_debug){
     bool fail = false;
     list<unsigned int>::iterator nli = nodelist.begin();
     while(nli != nodelist.end()){
       // Make sure NO ghost nodes live in real elements
       if(*nli > nreal_volume_nodes){
         unsigned int nrel = 0;
         // Check real triangles
         vector<unsigned int>::iterator ti = _triconn.begin();
         while(nrel < nreal_tris){
           int ein = 0;
           while(ein < 3){
             if((unsigned int)*nli == (unsigned int)*ti++){
               if(_out)
                 *_out << "GEM_DomainBoundary::PopulateSurfaceArrays:"
                       << " Found ghost node, volume_id(" 
                       << *nli 
                       << ") in real tri(" << nrel+1 
                       << ") of surface " << _id << ". Aborting." << endl;
               fail = true;
             }
             ein++;
           }
           nrel++;
         }
         // Check real quads
         nrel = 0;
         ti = _quadconn.begin();
         while(nrel < nreal_quads){
           int ein = 0;
           while(ein < 4){
             if(*nli == *ti++){
               if(_out)
                 *_out << "GEM_DomainBoundary::PopulateSurfaceArrays:"
                       << " Found ghost node, volume_id(" 
                       << *nli << ") in real quad(" << nrel+1 
                       << ") of surface " << _id << ". Aborting." << endl;
               fail = true;
             }
             ein++;
           }
           nrel++;
         }       
       }
       // It's a real node, warn if it's isolated
       else { 
         unsigned int nrel = 0;
         // Check real triangles
         vector<unsigned int>::iterator ti = _triconn.begin();
         bool found = false;
         while(nrel < nreal_tris && !found){
           int ein = 0;
           while(ein < 3 && !found){
             if((unsigned int)*nli == (unsigned int)*ti++)
               found = true;
             ein++;
           }
           nrel++;
         }
         // Check real quads
         nrel = 0;
         ti = _quadconn.begin();
         while(nrel < nreal_quads && !found){
           int ein = 0;
           while(ein < 4 && !found){
             if(*nli == *ti++)
               found = true;
             ein++;
           }
           nrel++;
         }
         if(!found && _out)
           *_out << "GEM_DomainBoundary::PopulateSurfaceArrays: WARNING: "
                 << " Found isolated real node(" << *nli << ") on surface."
                 << std::endl;
       }
       nli++;
     }
     if(fail){
       if(_out)
         *_out << "GEM_DomainBoundary::PopulateSurfaceArrays: "
               << "Aborting due to previous errors." << std::endl;
       exit(1);
     }
   }
   surface_coordinates.resize(3*nodelist.size());
   unsigned int nghosts = 0;
   unsigned int nvol_real = ic.size()/3 - ngnodes;
   unsigned int real_node = 0;
   unsigned int ghost_node = 0;
   list<unsigned int>::iterator nli = nodelist.begin();
   while(nli != nodelist.end())
     if(*nli++ > nvol_real)
       nghosts++;
   nli = nodelist.begin();
   unsigned int nreal_nodes = nodelist.size() - nghosts;
   if(_debug && _out){
     *_out  << "GEM_DomainBoundary::PopulateSurfaceArrays(" << _id 
            << "): Nodes("
            << nreal_nodes << "," << nghosts << ")\n";
   }
   while(nli != nodelist.end()){
     unsigned int node = *nli++; // the volume node index
     if(node > nvol_real){
       surface_coordinates[(nreal_nodes+ghost_node)*3]   = ic[(node -1)*3];
       surface_coordinates[(nreal_nodes+ghost_node)*3+1] = ic[(node -1)*3+1];
       surface_coordinates[(nreal_nodes+ghost_node)*3+2] = ic[(node -1)*3+2];
       ghost_node++;
       s2v_imap.insert(make_pair(node,nreal_nodes+ghost_node));
     }
     else{
       surface_coordinates[real_node*3]   = ic[(node-1)*3];
       surface_coordinates[real_node*3+1] = ic[(node-1)*3+1];
       surface_coordinates[real_node*3+2] = ic[(node-1)*3+2];
       real_node++;
       s2v_imap.insert(make_pair(node,real_node));
     }
   }
   surface_ngnodes = ghost_node;
   ci = _triconn.begin();
   surface_tri.resize(_triconn.size());
   surface_quad.resize(_quadconn.size());
   unsigned int ind = 0;
   while(ci != _triconn.end())
     surface_tri[ind++] = s2v_imap[*ci++];
   ind = 0;
   ci = _quadconn.begin();
   while(ci != _quadconn.end())
     surface_quad[ind++] = s2v_imap[*ci++];
   if(_debug && _out)
     *_out  << "GEM_DomainBoundary::PopulateSurfaceArrays(" << _id 
            << "): Exit\n";
 }

Here is the caller graph for this function:

bool Register_com_surfmesh ( const std::string & wname )

Definition at line 545 of file GEM.C.

References COM_set_array(), and COM_set_size().

Referenced by GEM_Partition::PopulateSurfaceWindow().

 {
   // Set the surface mesh entity sizes and register the arrays
   COM_set_size((wname+".nc"),pane_id,surface_coordinates.size()/3,
                surface_ngnodes);
   COM_set_array((wname+".nc"),pane_id,&surface_coordinates[0],3);
   unsigned int nreal = _triconn.size()/3 - _ngtri;
   if(nreal > 0){
     COM_set_size((wname+".:t3:real"),pane_id,nreal);
     COM_set_array((wname+".:t3:real"),pane_id,&(surface_tri[0]),3);
   }
   nreal = _quadconn.size()/4 - _ngquad;
   if(nreal > 0){
     COM_set_size((wname+".:q4:real"),pane_id,nreal);
     COM_set_array((wname+".:q4:real"),pane_id,&(surface_quad[0]),4);
   }
   if(_ngtri > 0){
     nreal = _triconn.size()/3-_ngtri;
     COM_set_size((wname+".:t3:virtual"),pane_id,_ngtri,_ngtri);
     COM_set_array((wname+".:t3:virtual"),pane_id,&(surface_tri[nreal*3]),3);
   }
   if(_ngquad > 0){
     nreal = _quadconn.size()/4-_ngquad;
     COM_set_size((wname+".:q4:virtual"),pane_id,_ngquad,_ngquad);
     COM_set_array((wname+".:q4:virtual"),pane_id,&(surface_quad[nreal*4]),4);
   }
   return(true);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void report ( )

Definition at line 181 of file GEM.C.

Referenced by GEM_Partition::report_domain_boundaries().

 {
   if(_out){
     *_out << "Domain Boundary  ID: " << _id << endl
           << " Triangles:  (" << _triconn.size()/3 << "," << _ngtri << ")" 
           << endl
           << " Quads:  (" << _quadconn.size()/4 << "," << _ngquad 
           << ")" << endl;
   }
 }

Here is the caller graph for this function:

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

Definition at line 1121 of file GEM.C.

 {
   _solver_data._string_data.push_back(wname);
   _solver_data._field_data.resize(2);
   unsigned int ncells = _triconn.size()/3 + _quadconn.size()/4;
   unsigned int nnodes = NNodes();
   if(_debug && _out)
     *_out << "GEM_DomainBoundary(" << _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);
 }