Mesh Class Reference

Class Mesh is the main class that holds all information to describe the current state of the mesh. More...

#include <Mesh.hpp>

Collaboration diagram for Mesh:

Classes
struct	Border
struct	BorderData
	Border data in CSR format. More...
class	BSExtent
	Simple Block Structured Mesh object. More...
class	Connectivity
	General connectivity object. More...
class	GenericCell_2
class	GenericElement
class	GeometricEntity
	Connects continuous to discrete. More...
class	MeshUtilityObject
class	NeighborHood
class	NodalCoordinates
struct	PartInfo
class	Partition
class	SolnMetaData
class	TestFace
struct	UnstructuredMesh

Public Types
typedef IRAD::Primitive::IndexType	IndexType
typedef IRAD::Primitive::ubyte	CellEntityIDType
typedef std::pair< IndexType, CellEntityIDType >	SubEntityId
typedef std::pair< SubEntityId, SubEntityId >	SymbolicFace
typedef std::vector< IndexType >	IndexVec
typedef IRAD::Primitive::MultiContainer < IndexType >::VecVec	MultiVec
typedef IRAD::Primitive::MultiContainer < IndexType, IndexType > ::VecMap	VecMap
typedef IRAD::Primitive::ubyte	GeoDimType
typedef std::string	GeoNameType

Public Member Functions
	Mesh ()
	~Mesh ()
void	addNode (Node *node)
	The following add/remove/get methods are utility methods to add, remove, or return instances of nodes, faces or elements. More...
void	addFace (Face *face)
void	addElement (Element *element)
void	removeNode (Node *node)
void	removeFace (Face *face)
void	removeElement (Element *element)
Node *	getNode (int ID)
	The following get methods return a node, face or element. More...
Face *	getFace (int ID)
Element *	getElement (int ID)
int	getNumNodes ()
	The following get methods return the number of nodes, faces, or elements currently in the model. More...
int	getNumFaces ()
int	getNumElements ()
boolean	addCohesive (int material1, int material2, int new_material=-1)
	The addCohesive method is the driver for the entire process of adding cohesive elements to the mesh. More...
void	replaceNode (Node *node, Node *new_node, ElementList *sep_elements, int new_material)
void	write_boundary (ostream &stream)

Public Attributes
const double	TOL = 1e-9
const double	LTOL = 0.0 - TOL
const double	HTOL = 1.0 + TOL

Private Member Functions
double	calcEdgeLength (int elementID)
double	getMinEdge ()
void	setMinEdge (double me)

Private Attributes
Node **	d_nodes
	An ordered array of all nodes in the mesh. More...
int	d_numNodes
	The number of Nodes in the nodes array. More...
int	d_nodeArraySize
	The current size of the nodes array (must be as big or bigger than numNodes). More...
Face **	d_faces
	1..* More...
int	d_numFaces
int	d_faceArraySize
Element **	d_elements
	Array of all the Elements in the mesh. More...
int	d_numElements
int	d_elementArraySize
double	minEdge

Friends
istream &	operator>> (istream &stream, Mesh &mesh)
	The mesh instream operator is used to drive the reading of the one input file to the code. More...
ostream &	operator<< (ostream &stream, Mesh &mesh)
	The mesh ostream operator is used to drive the writing of both output fils from the code. More...

Detailed Description

Class Mesh is the main class that holds all information to describe the current state of the mesh.

It has several arrays that are arrays of node, face, and element objects. It contains the main work method for the cohesive insertion algorithm "addCohesive" that will be called from the main program.

Definition at line 19 of file Mesh.hpp.

Member Typedef Documentation

typedef IRAD::Primitive::ubyte CellEntityIDType

Definition at line 58 of file Mesh.H.

typedef IRAD::Primitive::ubyte GeoDimType

Definition at line 64 of file Mesh.H.

typedef std::string GeoNameType

Definition at line 65 of file Mesh.H.

typedef IRAD::Primitive::IndexType IndexType

Definition at line 57 of file Mesh.H.

typedef std::vector<IndexType> IndexVec

Definition at line 61 of file Mesh.H.

typedef IRAD::Primitive::MultiContainer<IndexType>::VecVec MultiVec

Definition at line 62 of file Mesh.H.

typedef std::pair<IndexType,CellEntityIDType> SubEntityId

Definition at line 59 of file Mesh.H.

typedef std::pair<SubEntityId,SubEntityId> SymbolicFace

Definition at line 60 of file Mesh.H.

typedef IRAD::Primitive::MultiContainer<IndexType,IndexType>::VecMap VecMap

Definition at line 63 of file Mesh.H.

Constructor & Destructor Documentation

Mesh

(

)

Definition at line 14 of file Mesh.cpp.

References minEdge, Element::setMesh(), and Face::setMesh().

           :
  d_nodes(0),
  d_numNodes(0),
  d_nodeArraySize(0),
  d_faces(0),
  d_numFaces(0),
  d_faceArraySize(0),
  d_elements(0),
  d_numElements(0),
  d_elementArraySize(0)
{

  Element::setMesh( this );
  Face::setMesh( this );
  minEdge = 1E+25;

}

Here is the call graph for this function:

~Mesh

(

)

Definition at line 32 of file Mesh.cpp.

References d_elements, d_faces, d_nodes, d_numElements, d_numFaces, d_numNodes, and i.

           {

  if( d_elements ){
    int i;
    for( i = 0; i < d_numElements; i++ ){
      delete d_elements[i];
    }
    delete [] d_elements;
  }

  if( d_faces ){
    int i;
    for( i = 0; i < d_numFaces; i++ ){
      delete d_faces[i];
    }
    delete [] d_faces;
  }

  if( d_nodes ){
    int i;
    for( i = 0; i < d_numNodes; i++ ){
      delete d_nodes[i];
    }
    delete [] d_nodes;
  }
}

Member Function Documentation

boolean addCohesive	(	int	material1,
		int	material2,
		int	new_material = -1
	)

The addCohesive method is the driver for the entire process of adding cohesive elements to the mesh.

Currently, it relies on the input of three integers: material 1 and material 2 are the element material types that should have cohesive elements inserted between them (they can be the same number if it is desired to insert cohesive elements between elements of the same type). new_material defaults to -1, and is the material type that cohesive elements will be assigned.

Definition at line 167 of file Mesh.cpp.

References d_faces, d_numFaces, FALSE, FaceList::get(), FaceListList::get(), NodeList::get(), Face::getElement1(), Face::getElement2(), Element::getMaterialType(), Face::getNodes(), Face::getNumNodes(), i, NodeList::index(), FaceListList::index(), FaceList::insert_first(), NodeList::insert_first(), FaceListList::insert_first(), Element::isCohesive(), j, NodeList::move_to(), FaceListList::next(), FaceList::next(), NodeList::next(), NodeList::reset(), FaceListList::reset(), FaceList::reset(), Node::separate(), FaceList::size(), NodeList::size(), and TRUE.

                                                                         {

  // go over all faces & for each one which has two elems
  // with the mat1 & mat2 - generate a cohesive (if neither of
  // the two  elems is cohesive) - have a list of those (to split
  // at nodes later)
  
  FaceList faces;

  // collect the faces
  int i;
  for( i = 0; i < d_numFaces; i++ ){
    Element *e1 = d_faces[i]->getElement1();
    Element *e2 = d_faces[i]->getElement2();
    if( e1 && e2 && !e1->isCohesive()
        && !e2->isCohesive()
        && ( ( e1->getMaterialType() == material1 
               && e2->getMaterialType() == material2 )
             || ( e1->getMaterialType() == material2 
                  && e2->getMaterialType() == material1 ) ) ){
      // fits
      faces.insert_first( d_faces[i] );
    }
  }

  // Collect nodes  & their faces

  NodeList sep_nodes;
  FaceListList node_faces;
  int size = faces.size();
  faces.reset();
  for( i = 0; i < size; i++ ){
    Face* face = faces.get();
    faces.next();
    int num = face->getNumNodes();
    Node** fnodes = face->getNodes();
    int j;
    for( j = 0; j < num; j++ ){
      if( sep_nodes.move_to( fnodes[j] ) ){
                int ind = sep_nodes.index();
                node_faces.index( ind );
                node_faces.get()->insert_first( face );
      }
      else {
                sep_nodes.insert_first( fnodes[j] );
                FaceList* newlist = new FaceList;
                newlist->insert_first( face );
                node_faces.insert_first( newlist );
      }
    }
  }

  // now go over the nodes & check if separable...

  // check at each node 
  // if have two element groups separated by cohesives (or our faces)
  // if yes separate the two. 
  
  int sep_count = 0;
  int node_size = sep_nodes.size();
  sep_nodes.reset();
  node_faces.reset();
  for( i = 0; i < node_size; i++ ) {
        int j = i;
    Node* node = sep_nodes.get();
    FaceList* flist = node_faces.get();
    sep_nodes.next();
    node_faces.next();
    boolean separated = node->separate( this, flist, new_material );
    if( separated ) sep_count++;
    delete flist;
  }
  cerr << " separated " << sep_count << " nodes, out of " << node_size 
       << " involved" << endl;
  
  return ( sep_count >0 ? TRUE : FALSE );
}

Here is the call graph for this function:

void addElement

(

Element *

element

)

Definition at line 131 of file Mesh.cpp.

References d_elementArraySize, d_elements, d_numElements, and Element::setID().

Referenced by replaceNode().

                                     {

  if( d_elementArraySize == d_numElements ){
    d_elementArraySize =  (int)( d_elementArraySize * 1.25 + 3);
    Element **new_arr = new Element*[d_elementArraySize];
    if( d_numElements > 0 ){
      memcpy(new_arr, d_elements, d_numElements * sizeof(Element*) );
      delete [] d_elements;
    }
    d_elements = new_arr;
  }
  d_elements[d_numElements] = element;
  element->setID(d_numElements + 1);
  d_numElements++;

}

Here is the call graph for this function:

Here is the caller graph for this function:

void addFace

(

Face *

face

)

Definition at line 96 of file Mesh.cpp.

References d_faceArraySize, d_faces, d_numFaces, face, and Face::setID().

Referenced by HexElement::setFaceFromNodes(), TetElement::setFaceFromNodes(), TCoElement::setFaceFromNodes(), and QCoElement::setFaceFromNodes().

                            {

  if( d_faceArraySize == d_numFaces ){
    d_faceArraySize =  (int)( d_faceArraySize * 1.25 + 3);
    Face **new_arr = new Face*[d_faceArraySize];
    if( d_numFaces > 0 ){
      memcpy(new_arr, d_faces, d_numFaces * sizeof(Face*) );
      delete [] d_faces;
    }
    d_faces = new_arr;
  }
  d_faces[d_numFaces] = face;
  face->setID(d_numFaces + 1);
  d_numFaces++;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void addNode

(

Node *

node

)

The following add/remove/get methods are utility methods to add, remove, or return instances of nodes, faces or elements.

Pointers to the node, face, or element to be added or removed must be provided.

Definition at line 60 of file Mesh.cpp.

References d_nodeArraySize, d_nodes, d_numNodes, and Node::setID().

Referenced by Node::separate().

                            {

  if( d_nodeArraySize == d_numNodes ){
    d_nodeArraySize =  (int)( d_nodeArraySize * 1.25 + 3);
    Node **new_arr = new Node*[d_nodeArraySize];
    if( d_numNodes > 0 ){
      memcpy(new_arr, d_nodes, d_numNodes * sizeof(Node*) );
      delete [] d_nodes;
    }
    d_nodes = new_arr;
  }
  d_nodes[d_numNodes] = node;
  node->setID(d_numNodes + 1);
  d_numNodes++;

}

Here is the call graph for this function:

Here is the caller graph for this function:

double calcEdgeLength ( int  elementID )

private

Definition at line 396 of file Mesh.cpp.

References d_elements.

Referenced by operator>>().

                                        {

   return(d_elements[elementID]->getMinEdgeLength());

}

Here is the caller graph for this function:

Element * getElement ( int  ID )

inline

Definition at line 143 of file Mesh.hpp.

References d_elements.

{ return d_elements[ID-1];}

Face * getFace ( int  ID )

inline

Definition at line 140 of file Mesh.hpp.

References d_faces.

Referenced by operator>>().

{return d_faces[ID-1];}

Here is the caller graph for this function:

double getMinEdge ( )

inlineprivate

Definition at line 155 of file Mesh.hpp.

References minEdge.

Referenced by operator<<(), and operator>>().

{ return minEdge; }

Here is the caller graph for this function:

Node * getNode ( int  ID )

inline

The following get methods return a node, face or element.

To return one of these objects, it's ID must be supplied. Note: in the input file, all nodes and elements are given IDs by the file author. However, this code assumes that the nodes and elements are supplied in "ID" order, and it just returns the array element [ID-1]. Thus, if you skip an ID in the input file, and then ask for element ID=50 (assume you skipped 40), you will actually get element 51 back (51 as listed in the input file, but it will be the 50th element that was in the input file).

Definition at line 137 of file Mesh.hpp.

References d_nodes.

Referenced by operator>>().

{ return d_nodes[ID-1]; }

Here is the caller graph for this function:

int getNumElements ( )

inline

Definition at line 152 of file Mesh.hpp.

References d_numElements.

{ return d_numElements; }

int getNumFaces ( )

inline

Definition at line 149 of file Mesh.hpp.

References d_numFaces.

Referenced by operator>>().

{ return d_numFaces; }

Here is the caller graph for this function:

int getNumNodes ( )

inline

The following get methods return the number of nodes, faces, or elements currently in the model.

These may not be the same as the sizes of the corresponding arrays in the Mesh class (d_nodes, etc. )

Definition at line 146 of file Mesh.hpp.

References d_numNodes.

{ return d_numNodes; }

void removeElement

(

Element *

element

)

Definition at line 148 of file Mesh.cpp.

References d_elements, d_numElements, i, and Element::setID().

                                         {

  int i;
  int dif = 0;
  for( i = 0; i < d_numElements; i++ ){
    if( d_elements[i] == element ){
      dif++;
      continue;
    }
    if( dif > 0 ){
      d_elements[i - dif] = d_elements[i];
      d_elements[i - dif]->setID( i - dif + 1 ); 
    }
  }
  d_numElements -= dif;

}

Here is the call graph for this function:

void removeFace

(

Face *

face

)

Definition at line 112 of file Mesh.cpp.

References d_faces, d_numFaces, i, and Face::setID().

                                {

  int i;
  int dif = 0;
  for( i = 0; i < d_numFaces; i++ ){
    if( d_faces[i] == face ){
      dif++;
      continue;
    }
    if( dif > 0 ){
      d_faces[i - dif] = d_faces[i];
      d_faces[i - dif]->setID( i - dif + 1 ); 
    }
  }
  d_numFaces -= dif;


}

Here is the call graph for this function:

void removeNode

(

Node *

node

)

Definition at line 77 of file Mesh.cpp.

References d_nodes, d_numNodes, i, and Node::setID().

                                {

  int i;
  int dif = 0;
  for( i = 0; i < d_numNodes; i++ ){
    if( d_nodes[i] == node ){
      dif++;
      continue;
    }
    if( dif > 0 ){
      d_nodes[i - dif] = d_nodes[i];
      d_nodes[i - dif]->setID( i - dif + 1 ); 
    }
  }
  d_numNodes -= dif;

}

Here is the call graph for this function:

void replaceNode	(	Node *	node,
		Node *	new_node,
		ElementList *	sep_elements,
		int	new_material
	)

Definition at line 245 of file Mesh.cpp.

References addElement(), ElementList::append(), Face::buildCohesive(), Face::containsNode(), ElementList::get(), FaceList::get(), Face::getElement1(), Face::getElement2(), Element::getFaces(), Element::getNumFaces(), i, ElementList::index(), FaceList::insert_first(), Element::isCohesive(), j, ElementList::move_to(), FaceList::next(), ElementList::next(), Element::replaceFaceNode(), Element::replaceNode(), ElementList::reset(), Element::setMaterialType(), ElementList::size(), and FaceList::size().

Referenced by Node::separate().

                                                                      {

  // add any cohesives which have one side inside the sep_elements

  int size = sep_elements->size();
  //out_faces will ultimately contain the list of faces that form the outside
  //of the sep_elements group of elements. 
  FaceList out_faces;
  int i;
  //for each element in the sep_elements list...
  for( i = 0; i < size; i++ ) {
    sep_elements->index(i);
    Element* elem = sep_elements->get();
    int numf = elem->getNumFaces();
    Face** faces = elem->getFaces();
    int j;
    //for each face in each element...
    for( j = 0; j < numf; j++ ){
      Face* face = faces[j];
      
      //see of this face contains the node we're working on...
      if( !face->containsNode( node ) ){
                continue;  //try next face
      }
      
      //if yes, get the element on the other side of this face...
      Element* oelem= (face->getElement1() == elem 
                    ? face->getElement2()
                    : face->getElement1() );
                    
          //if its an outside face (no second element), then go to the next face...
      if( !oelem ){
                continue;
      }
      
      //if the second element is already on our element list, go to next face...
      if( sep_elements->move_to( oelem ) ){
                continue;
      }
      
      //otherwise, if it's a cohesive element on the other side of the face...
      if( oelem->isCohesive() ) {
        //get the second face of the cohesive element (first is in "face")
                Face** cofaces = oelem->getFaces();
                Face* oface = ( cofaces[0] == face ? cofaces[1] : cofaces[0] );
                //now get the element that is on the other side of the cohesive element
                Element* other = (oface->getElement1() == oelem 
                          ? oface->getElement2()
                          : oface->getElement1() );
                //if that other element is already on our list of elements, then append 
                //the first one to the list (it wasn't on our list - we checked above). 
                if( sep_elements->move_to( other ) ) {
                        sep_elements->append( oelem );
                }
                else { 
                        //otherwise add the face we're working with to the out_faces list. 
                        //(if the opposite element does not belong in our element list, then it is
                        //an outside "separator" face)
                        out_faces.insert_first( face );
                }
      } // if( oelem->isCohesive() )
      else { //if the other element is not cohesive, and is not in the sep_elements list, 
                //then it is a boundary.
                out_faces.insert_first( face );
      }
      
    } //for( j = 0 ...
  } //  for( i = 0 ...
  
  int num_out_faces = out_faces.size();
   
  //Task:  if the face does not belong to a cohesive element, then we have to make one. 
  //Otherwise, we need to replace the node in the current face.  Somewhere here there
  //is a bug right now (8/13/01)
  
  //for each face in the out_faces array, get the elements on either side.
  for( i = 0; i < num_out_faces; i++ ){
    Face *face = out_faces.get();
    out_faces.next();
    Element* e1 = face->getElement1();
    Element* e2 = face->getElement2();
    if( !e2 ) { // the sep replacement will handle
      continue;
    }
    //if neither of them are cohesive, add a cohesive element between them.
    if( !e1->isCohesive() && !e2->isCohesive() ){
    //elem is used to ensure correct direction of the normals. 
      Element* elem = ( sep_elements->move_to( e1 ) ? e1 : e2 );
      Element* new_elem = face->buildCohesive( elem, node, new_node );
      new_elem->setMaterialType( new_material );
      addElement( new_elem );
   }
    else if( e1->isCohesive() ){ // e2 is in sep
      e1->replaceFaceNode( node, new_node, face );
    }
    else {
      e2->replaceFaceNode( node, new_node, face );
    }
  }

  // go and replace in all the elements
  // including inside the faces 
  //replace nodes in the elements in the sep_element list.  Bug may be here as well. 
  sep_elements->reset();
  size = sep_elements->size();
  for( i = 0; i < size; i++ ){

    sep_elements->get()->replaceNode( node, new_node );
    sep_elements->next();
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void setMinEdge ( double  me )

inlineprivate

Definition at line 158 of file Mesh.hpp.

References minEdge.

Referenced by operator>>().

{ minEdge = me ; }

Here is the caller graph for this function:

void write_boundary

(

ostream &

stream

)

Definition at line 507 of file Mesh.cpp.

References d_faces, d_numFaces, Face::getElement1(), Element::getFaces(), Face::getFlag(), Element::getID(), Element::getNumFaces(), i, and j.

                                          {

  int count = 0;
  int i;
  for( i = 0; i < d_numFaces; i++ ){
    if( d_faces[i]->isExterior() ){
      count++;
    }
  }
  stream << count << endl;

  for( i = 0; i < d_numFaces; i++ ){
    if( d_faces[i]->isExterior() ){
      Element* e1 = d_faces[i]->getElement1();
      stream << e1->getID() << '\t';
      int numf = e1->getNumFaces();
      Face** efaces = e1->getFaces();
      int j;
      for( j = 0; j < numf; j++ ){
                if( d_faces[i] == efaces[j] ){
                        stream << j + 1 << '\t' << d_faces[i]->getFlag() << endl;
                        break;
                }
      }
    }
  }
}

Here is the call graph for this function:

Friends And Related Function Documentation

ostream& operator<< ( ostream &  stream, Mesh &  mesh  )

friend

The mesh ostream operator is used to drive the writing of both output fils from the code.

These output files are the augmented node/element file (now containing cohesive elements), and the surface node description file. Note that the ostream operators for other classes actually do much of the work (i.e., node << knows how to write a node, element << knows how to write an element, etc.).

Definition at line 359 of file Mesh.cpp.

                                                   {

  int j;
  int numcohesive = 0;
  for (j=0; j<mesh.d_numElements; j++) {
        if ((*mesh.d_elements[j]).isCohesive()) numcohesive += 1;
  }

  stream << (mesh.d_numElements - numcohesive) << '\t' <<  mesh.d_numNodes 
         << '\t' << numcohesive << '\t' << mesh.getMinEdge() <<endl;

  stream.setf(ios::uppercase);
  stream.setf(ios::scientific,ios::floatfield);
  stream.precision(9);
  int numbc_nodes = 0;
  int i;
  for( i = 0; i < mesh.d_numNodes;i++ ){
    stream << (*mesh.d_nodes[i]); 
    if( mesh.d_nodes[i]->getFlag() != Node::e_unset_flag ){
      numbc_nodes++;
    }
  }
  stream << numbc_nodes << endl;
  for( i = 0; i < mesh.d_numNodes;i++ ){
    if( mesh.d_nodes[i]->getFlag() != Node::e_unset_flag ){
      stream <<  mesh.d_nodes[i]->getID() << '\t' << mesh.d_nodes[i]->getFlag()<< endl;
    }
  }
  for( i = 0; i < mesh.d_numElements; i++ ){
    stream << (*mesh.d_elements[i]);
  }
  
  return stream;
}

istream& operator>> ( istream &  stream, Mesh &  mesh  )

friend

The mesh instream operator is used to drive the reading of the one input file to the code.

This input file contains the node and element definitions for the mesh. Note that the instream operators for other classes actually do much of the work (i.e., node >> knows how to read a node, element >> knows how to read an element, etc.).

Definition at line 402 of file Mesh.cpp.

                                                   {

  int numn;
  int nume;
  stream >> nume >> numn;
  
  mesh.d_nodeArraySize = numn;
  mesh.d_nodes = new Node*[numn];
  // read nodes
  int i;
  for( i = 0; i < numn;i++ ){
    mesh.d_nodes[i] = new Node();
    stream >> (*mesh.d_nodes[i]);
  }
  mesh.d_numNodes = numn;

  mesh.d_elementArraySize = nume;
  mesh.d_elements = new Element*[nume];

  // assume ~ twice as elements

  mesh.d_faceArraySize = nume * 2;
  mesh.d_faces = new Face*[mesh.d_faceArraySize];


  for( i = 0; i < nume;i++ ){
    int id, type;
    double currentEdge;
    stream >> id >> type;
    mesh.d_elements[i] = Element::create( id, (Element::Type)type );
    stream >> (*mesh.d_elements[i]);
    currentEdge = (mesh.calcEdgeLength(i));
    if (currentEdge < mesh.getMinEdge()) mesh.setMinEdge(currentEdge);
  }
  mesh.d_numElements = nume;
  // read groups

  int numbcn;
  stream >> numbcn;
  // read nodes with flag
  for( i = 0; i < numbcn; i++ ){
    int num;
    int flag;
    stream >> num >> flag;
    mesh.d_nodes[num-1]->setFlag( flag );
  }
  
  //read faces with flag (three nodes and the flag)
  int numFaceFlags, numFaceNodes, elementtype, theflag, totalFaces;
  
  stream >> numFaceFlags;  //number of faces in input file with flags
  totalFaces = mesh.getNumFaces(); //total number of existing faces in mesh
  
  for (i=0 ; i < numFaceFlags ; i++) {
        stream >> elementtype;  //type of element the face is associated with
        //make a temporary working face to hold the node info
        Face* theFace = Face::create((Face::eType)elementtype);
        stream >> *theFace;
        stream >> theflag;
        numFaceNodes = theFace->getNumNodes(); //number of nodes in this face
        
        //take "theFace" and compare it's nodes against the nodes in every face in the 
        //Mesh list of faces until we find a match.  When we find a match, set it's flag,
        //and then go on to the next face in the list.  This is very inefficient, but
        //without knowing what element the supplied face is in, I don't know how else to
        //go about it. 
        int j;
        for (j=0; j < totalFaces; j++) {
                Face* trialFace = mesh.getFace(j+1);  //getFace assumes ID's starting with 1
                Node** theNodes = theFace->getNodes();
                Node** trialNodes = trialFace->getNodes();
                boolean nodeFound;
                int numFound;
                numFound=0;
                
                //for each node in the face to be found...
                int k;
                for (k=0; k<numFaceNodes; k++) {
                        nodeFound=FALSE;
                        int numExistingFaceNodes;
                        numExistingFaceNodes = trialFace->getNumNodes();
                        if (numFaceNodes != numExistingFaceNodes) break; //faces aren't compatible
                        
                        //...see if it's in the current face in the mesh that we're looking at.
                        int m;
                        for (m=0; m<numExistingFaceNodes; m++) {
                                if(theNodes[k]==trialNodes[m]) {
                                        nodeFound=TRUE;
                                        numFound++;
                                        break;
                                }
                        }
                        if(!nodeFound) break;  //if we didn't find the node, try the next face
                        //if we found all the nodes in any face, then set the flag and read the next face in.
                        if(numFound==numFaceNodes) {
                                trialFace->setFlag(theflag);
                                break;
                        }
                }
        }
        delete theFace;
  }
  return stream;
}

Member Data Documentation

int d_elementArraySize

private

Definition at line 131 of file Mesh.hpp.

Referenced by addElement(), and operator>>().

Element** d_elements

private

Array of all the Elements in the mesh.

1..*

Definition at line 129 of file Mesh.hpp.

Referenced by addElement(), calcEdgeLength(), getElement(), operator<<(), operator>>(), removeElement(), and ~Mesh().

int d_faceArraySize

private

Definition at line 123 of file Mesh.hpp.

Referenced by addFace(), and operator>>().

Face** d_faces

private

1..*

Definition at line 121 of file Mesh.hpp.

Referenced by addCohesive(), addFace(), getFace(), operator>>(), removeFace(), write_boundary(), and ~Mesh().

int d_nodeArraySize

private

The current size of the nodes array (must be as big or bigger than numNodes).

Used for dynamic allocation of space for the array.

Definition at line 116 of file Mesh.hpp.

Referenced by addNode(), and operator>>().

Node** d_nodes

private

An ordered array of all nodes in the mesh.

The index of each Node in the array is also stored as the ID in the Node object. 1..*

Definition at line 105 of file Mesh.hpp.

Referenced by addNode(), getNode(), operator<<(), operator>>(), removeNode(), and ~Mesh().

int d_numElements

private

Definition at line 130 of file Mesh.hpp.

Referenced by addElement(), getNumElements(), operator<<(), operator>>(), removeElement(), and ~Mesh().

int d_numFaces

private

Definition at line 122 of file Mesh.hpp.

Referenced by addCohesive(), addFace(), getNumFaces(), removeFace(), write_boundary(), and ~Mesh().

int d_numNodes

private

The number of Nodes in the nodes array.

Definition at line 110 of file Mesh.hpp.

Referenced by addNode(), getNumNodes(), operator<<(), operator>>(), removeNode(), and ~Mesh().

const double HTOL = 1.0 + TOL

Definition at line 55 of file Mesh.H.

const double LTOL = 0.0 - TOL

Definition at line 54 of file Mesh.H.

double minEdge

private

Definition at line 133 of file Mesh.hpp.

Referenced by getMinEdge(), Mesh(), and setMinEdge().

const double TOL = 1e-9

Definition at line 53 of file Mesh.H.

---

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

• Mesh.hpp
• Mesh.H
• Mesh.cpp