Mesh.cpp File Reference

#include <string.h>
#include "Mesh.hpp"
#include "Element.hpp"
#include "Face.hpp"
#include "Node.hpp"
#include "IntList.hpp"
#include "NodeList.hpp"
#include "ElementList.hpp"
#include "FaceList.hpp"
#include "FaceListList.hpp"

Include dependency graph for Mesh.cpp:

Go to the source code of this file.

Functions
ostream &	operator<< (ostream &stream, Mesh &mesh)
istream &	operator>> (istream &stream, Mesh &mesh)

Function Documentation

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

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.

References Mesh::d_elements, Mesh::d_nodes, Mesh::d_numElements, Mesh::d_numNodes, Node::e_unset_flag, Node::getFlag(), Node::getID(), Mesh::getMinEdge(), i, and j.

                                                   {

  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;
}

Here is the call graph for this function:

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

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.

References Mesh::calcEdgeLength(), Element::create(), Face::create(), Mesh::d_elementArraySize, Mesh::d_elements, Mesh::d_faceArraySize, Mesh::d_faces, Mesh::d_nodeArraySize, Mesh::d_nodes, Mesh::d_numElements, Mesh::d_numNodes, FALSE, Mesh::getFace(), Mesh::getMinEdge(), Face::getNodes(), Mesh::getNumFaces(), Face::getNumNodes(), i, id(), j, k, Face::setFlag(), Node::setFlag(), Mesh::setMinEdge(), and TRUE.

                                                   {

  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;
}

Here is the call graph for this function: