Inheritance diagram for FEMesh:

Collaboration diagram for FEMesh:

Public Member Functions
	FEMesh (FEMesh &m)

void	Create (int nodes, int elems, int faces=0, int edges=0)
	allocate space for mesh

void	ShallowCopy (FEMesh *pm)

void	Clear ()
	— C L E A N U P —

void	DeleteEdges ()

int	Elements () const
	return number of elements

FEElement &	Element (int n)
	return element

FEElement_ &	ElementRef (int n)
	return reference to element

FEElement *	ElementPtr (int n=0)
	return pointer to element

int	FindFace (FEElement *pe, FEFace &f, FEFace &fe)

void	FindNodesFromPart (int gid, vector< int > &node)

std::vector< FENode > &	NodeArray ()

std::vector< FEFace > &	FaceArray ()

std::vector< FEElement > &	ElementArray ()

double	GetElementValue (int n)

void	SetElementValue (int n, double v)

void	UpdateValueRange ()

void	GetValueRange (double &vmin, double &vmax)

vec3d	ProjectToSurface (vec3d r, vec3d t)

vec3d	ProjectToFace (vec3d p, FEFace &f, double &r, double &s)

vec3d	ProjectToEdge (vec3d e1, vec3d e2, vec3d p, double &r)

bool	FindIntersection (FEFace &f, vec3d x, vec3d n, vec3d &q, double &g)

void	Update ()

void	UpdateElementNeighbors ()

void	UpdateFaces ()

void	UpdateEdges ()

void	UpdateNodes ()

void	AutoSmooth (double w)

void	UpdateNormals ()

void	PartitionSelection ()

void	RemoveIsolatedNodes ()

void	AddNode (FENode &n)

FEMesh *	DetachSelectedMesh ()

void	DetachSelectedPart ()

FEMesh *	ExtractSelectedFaces ()

void	DeleteTaggedElements (int tag)

void	DeleteTaggedFaces (int tag)

void	DeleteTaggedEdges (int tag)

void	FindDuplicateFaces (vector< int > &l)
	This function identifies duplicate faces and returns a list with the duplicates.

void	FindDuplicateEdges (vector< int > &l)
	This function identifies duplicate edges and returns a list with the duplicates.

void	DeleteSelectedElements ()

void	DeleteSelectedFaces ()

void	DeleteSelectedNodes ()

void	InvertTaggedElements (int ntag)

void	InvertSelectedElements ()

double	ShellJacobian (FEElement &el)

void	RemoveDuplicateElements ()

void	FixinvertedElements ()

void	FixReferenceSurface ()

void	InterpolateShellThickness (double)

void	RemoveNonManifoldElements ()

void	FixElementWinding ()

void	FixElementWinding2 ()

void	TagAllElements (int ntag)

int	DataFields ()

FEElementData *	AddDataField (const char *szname, double v=0.0)

FEElementData &	GetDataField (int i)

double	ShortestEdge ()

void	BuildNodeElementTable (vector< vector< int > > &NET)

void	BuildNodeFaceTable (vector< vector< int > > &NFT)

void	BuildNodeEdgeTable (vector< vector< int > > &NET)

void	BuildEdgeTable (vector< pair< int, int > > &ET)

void	BuildNodeNodeTable (vector< set< int > > &NNT)

void	BuildSurfaceNodeNodeTable (vector< set< int > > &NNT)

void	BuildElementEdgeTable (vector< vector< int > > &EET, vector< pair< int, int > > &ET)

void	BuildFaceTable (vector< FEFace > &FT)

void	BuildElementFaceTable (vector< vector< int > > &EFT, vector< FEFace > &FT)

void	BuildFaceEdgeTable (vector< vector< int > > &FET, vector< pair< int, int > > &ET)

void	BuildFaceFaceTable (vector< int > &FFT, vector< FEFace > &FT)

void	BuildEdgeEdgeTable (vector< int > &EET, vector< pair< int, int > > &ET)

Public Member Functions inherited from FECoreMesh
	FECoreMesh ()
	constructor

virtual	~FECoreMesh ()
	destructor

bool	IsType (int ntype)
	check the type of the mesh More...

int	Nodes () const

int	Edges () const

int	Faces () const

FENode &	Node (int n)

FEEdge &	Edge (int n)

FEFace &	Face (int n)

FENode *	NodePtr (int n=0)

FEEdge *	EdgePtr (int n=0)

FEFace *	FacePtr (int n=0)

Protected Member Functions
bool	IntersectTri (vec3d *y, vec3d x, vec3d n, vec3d &q, double &g)

bool	IntersectQuad (vec3d *y, vec3d x, vec3d n, vec3d &q, double &g)

Protected Attributes
std::vector< FEElement >	m_Elem
	FE elements.

std::vector< double >	m_data
	element values

double	m_min

double	m_max
	value range of element data

vector< FEElementData >	m_map

Protected Attributes inherited from FECoreMesh
std::vector< FENode >	m_Node
	FE nodes.

std::vector< FEEdge >	m_Edge
	FE edges.

std::vector< FEFace >	m_Face
	FE faces.

Detailed Description

Definition at line 57 of file FEMesh.h.

Member Function Documentation

FEMesh * FEMesh::DetachSelectedMesh ( )

Update();

Definition at line 272 of file FEMesh.cpp.

 {
      int i, j, n;
 
      // count selected elements
      int elems = 0;
      FEElement* pe = ElementPtr();
      for (i=0; i<Elements(); ++i, ++pe) if (pe->IsSelected()) ++elems;
 
      // make sure there is a selection
      if (elems == 0) return 0;
 
      // tag nodes that will be moved to the new mesh
      FENode* pn = NodePtr();
      for (i=0; i<Nodes(); ++i, ++pn) pn->m_ntag = -1;
 
      pe = ElementPtr();
      for (i=0; i<Elements(); ++i, ++pe)
      {
           if (pe->IsSelected())
           {
                n = pe->Nodes();
                for (j=0; j<n; ++j) Node(pe->m_node[j]).m_ntag = 1;
           }
      }
 
      // count nodes
      int nodes = 0;
      pn = NodePtr();
      for (i=0; i<Nodes(); ++i, ++pn) if (pn->m_ntag > 0) ++nodes;
 
      // create a new mesh
      FEMesh* pm = new FEMesh();
      pm->Create(nodes, elems);
 
      // create the new nodes
      pn = NodePtr();
      n = 0;
      for (i=0; i<Nodes(); ++i, ++pn)
      {
           if (pn->m_ntag > 0)
           {
                FENode& node = pm->Node(n);
                node.r  = pn->r;
                pn->m_ntag = n++;
           }
      }
      assert(n == nodes);
 
      // create the new elements
      pe = ElementPtr();
      n = 0;
      for (i=0; i<Elements(); ++i, ++pe)
      {
           if (pe->IsSelected())
           {
                FEElement& el = pm->Element(n);
                el.SetType(pe->GetType());
                el.m_h[0] = pe->m_h[0];
                el.m_h[1] = pe->m_h[1];
                el.m_h[2] = pe->m_h[2];
                el.m_h[3] = pe->m_h[3];
                
                for (j=0; j<pe->Nodes(); ++j)
                {
                     el.m_node[j] = Node(pe->m_node[j]).m_ntag;
                     assert(el.m_node[j] >= 0);
                }
                ++n;
           }
      }
      assert(n==elems);
 
      // update the new mesh (is done later)
 //   pm->Update();
 
      vector<int> ELT;
      ELT.assign(Elements(), -1);
 
      // the new mesh is created, so let's clean up this mesh
      // delete selected elements
      n = 0;
      for (i=0; i<Elements(); ++i)
      {
           FEElement& e0 = Element(i);
           FEElement& e1 = Element(n);
 
           if (!e0.IsSelected())
           {
                e1 = e0;
                ELT[i] = n;
                ++n;
           }
      }
      m_Elem.resize(n);
      m_data.resize(n);
 
      // tag nodes which will be kept
      pn = NodePtr();
      for (i=0; i<Nodes(); ++i, ++pn) pn->m_ntag = -1;
 
      pe = ElementPtr();
      for (i=0; i<Elements(); ++i, ++pe)
      {
           n = pe->Nodes();
           for (j=0; j<n; ++j) Node(pe->m_node[j]).m_ntag = 1;
      }
 
      // reindex the nodes
      n = 0;
      pn = NodePtr();
      for (i=0; i<Nodes(); ++i, ++pn) if (pn->m_ntag > 0) pn->m_ntag = n++;
 
      pe = ElementPtr();
      for (i=0; i<Elements(); ++i, ++pe)
      {
           n = pe->Nodes();
           for (j=0; j<n; ++j) pe->m_node[j] = Node(pe->m_node[j]).m_ntag;
      }
 
      // delete untagged nodes
      n = 0;
      for (i=0; i<Nodes(); ++i)
      {
           FENode& n0 = Node(i);
           FENode& n1 = Node(n);
 
           if (n0.m_ntag >= 0)
           {
                n1 = n0;
                ++n;
           }
      }
      m_Node.resize(n);
 
      // update the mesh (is done later)
 
      // Done!
      return pm;
 }

bool FEMesh::IntersectQuad	(	vec3d *	y,
		vec3d	r,
		vec3d	n,
		vec3d &	q,
		double &	g
	)

protected

This function calculates the intersection of a ray with a quad and returns true if the ray intersected.

Definition at line 2729 of file FEMesh.cpp.

 {
      // first we're going to see if the ray intersects the two subtriangles
      vec3d x1[3], x2[3];
      x1[0] = y[0]; x2[0] = y[2];
      x1[1] = y[1]; x2[1] = y[3];
      x1[2] = y[3]; x2[2] = y[1];
 
      bool b = false;
      double rp, sp;
 
      double eps = 0.01;
 
      if (IntersectTri(x1, r, n, q, g))
      {
           // we've intersected the first triangle
           b = true;
           rp = 0;
           sp = 0;
      }
      else if (IntersectTri(x2, r, n, q, g))
      {
           // we've intersected the second triangle
           b = true;
           rp = 0;
           sp = 0;
      }
 
      // if one of the triangels was intersected,
      // we calculate a more accurate projection
      if (b)
      {
           mat3d A;
           vec3d dx;
           vec3d F, F1, F2, F3;
           double H[4], H1[4], H2[4];
 
           double l1 = rp;
           double l2 = sp;
           double l3 = g;
           
           int nn = 0;
           int maxn = 5;
           do
           {
                // shape functions of quad
                H[0] = 0.25*(1 - l1)*(1 - l2);
                H[1] = 0.25*(1 + l1)*(1 - l2);
                H[2] = 0.25*(1 + l1)*(1 + l2);
                H[3] = 0.25*(1 - l1)*(1 + l2);
                q = y[0]*H[0] + y[1]*H[1] + y[2]*H[2] + y[3]*H[3];
 
                // shape function derivatives
                H1[0] = -0.25*(1 - l2); H2[0] = -0.25*(1 - l1);
                H1[1] =  0.25*(1 - l2); H2[1] = -0.25*(1 + l1);
                H1[2] =  0.25*(1 + l2); H2[2] =  0.25*(1 + l1);
                H1[3] = -0.25*(1 + l2); H2[3] =  0.25*(1 - l1);
 
                // calculate residual
                F = r + n*l3 - q;
 
                // residual derivatives
                F1 = - y[0]*H1[0] - y[1]*H1[1] - y[2]*H1[2] - y[3]*H1[3];
                F2 = - y[0]*H2[0] - y[1]*H2[1] - y[2]*H2[2] - y[3]*H2[3];
                F3 = n;
 
                // set up the tangent matrix
                A[0][0] = F1.x; A[0][1] = F2.x; A[0][2] = F3.x;
                A[1][0] = F1.y; A[1][1] = F2.y; A[1][2] = F3.y;
                A[2][0] = F1.z; A[2][1] = F2.z; A[2][2] = F3.z;
 
                // calculate solution increment
                mat3d Ai(A);
                Ai.Invert();
                dx = -(Ai*F);
 
                // update solution
                l1 += dx.x;
                l2 += dx.y;
                l3 += dx.z;
 
                ++nn;
           }
           while ((dx.Length() > 1e-7) && (nn < maxn));
 
           // store results
           rp = l1;
           sp = l2;
           g  = l3;
 
           // see if the point is inside the quad
           if ((rp >= -1-eps) && (rp <= 1+eps) && 
                (sp >= -1-eps) && (sp <= 1+eps)) return true;
      }
 
      return false;
 }

std::vector<FENode>& FEMesh::NodeArray ( )

inline

Get the node array

Todo:: Maybe I should delete these

Definition at line 97 of file FEMesh.h.

97 { return m_Node; }

FECoreMesh::m_Node

std::vector< FENode > m_Node

FE nodes.

Definition: FECoreMesh.h:49

void FEMesh::UpdateFaces ( )

This function finds the face neighbours. Note that internal faces cannot be neighbours of external faces.

Todo:: The FEAutoMesher::BuildFaces also assign the FEFace.m_elem variables. I should probably change this so that only one of these two functions does this.

Definition at line 1853 of file FEMesh.cpp.

 {
      int i, j, k, n, m, inode, nval;
      int NF = Faces();
 
      // make sure we have faces
      assert(NF);
 
      // first we need to figure out which face belongs to which element
      // first build the node element table
      vector< vector<int> > NET;
      BuildNodeElementTable(NET);
 
      // loop over all faces
      int f2[9];
      for (i=0; i<NF; ++i)
      {
           FEFace& f = Face(i);
           int m1 = f.m_nodes;
           f.m_elem[0] = -1;
           f.m_elem[1] = -1;
 
           // pick a node on the face
           inode = f.n[0];
           nval = NET[inode].size();
           m = 0;
           for (j=0; j<nval; ++j)
           {
                int ni = NET[inode][j];
                FEElement* pe = ElementPtr(ni);
 
                // search solid elements
                if (pe->IsSolid())
                {
                     n = pe->Faces();
                     for (k=0; k<n; ++k)
                     {
                          int m2 = pe->GetFace(k, f2);
                          if ((m1 == m2) && cmp_fn(f.n, f2, m1))
                          {
                               assert(m<2);
                               if (m == 0) f.m_elem[m++] = ni;
                               else
                               {
                                    int n0 = f.m_elem[0];
                                    if (ni < n0) { f.m_elem[0] = ni; f.m_elem[1] = n0; } else { f.m_elem[0] = n0; f.m_elem[1] = ni; }
                               }
                               pe->m_face[k] = i;
                          }
                     }
                }
                else if (pe->IsShell())
                {
                     FEFace f2 = pe->GetShellFace();
                     if (f == f2)
                     {
                          assert(m<2);
                          if (m<2)
                          {
                               f.m_elem[m++] = ni;
                               pe->m_face[0] = i;
                          }
                     }
                }
           }
 
           assert(f.m_elem[0] != -1);
      }
 
      // build the node-face table
      vector< vector<int> > NFT;
      BuildNodeFaceTable(NFT);
 
      // find all face neighbours
      int n1, n2;
      for (i=0; i<NF; ++i)
      {
           FEFace* pf = FacePtr(i);
 
           int nf = pf->Nodes();
           n = pf->Edges();
           for (j=0; j<n; ++j)
           {
                n1 = pf->n[j];
                n2 = pf->n[(j+1)%n];
                nval = NFT[n1].size();
                pf->m_nbr[j] = -1;
                for (k=0; k<nval; ++k)
                {
                     FEFace* pfn = FacePtr(NFT[n1][k]);
                     if (pfn != pf)
                     {
                          if (pfn->HasEdge(n1, n2))
                          {
                               if (pf->IsExternal())
                               {
                                    if (pfn->IsExternal()) { pf->m_nbr[j] = NFT[n1][k]; break; }
                               }
                               else if (!pfn->IsExternal()) { pf->m_nbr[j] = NFT[n1][k]; break; }
                          }
                     }
                }
           }
      }
 
 #ifdef _DEBUG
      // see if all faces belong to at least one element
      for (i=0; i<NF; ++i)
      {
           FEFace& f = Face(i);
           assert(f.m_elem[0] >= 0);
      }
 #endif
 
 }

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

C:/Users/Brig/Documents/ShapeWorksStudio/src/Surfworks/PreViewMeshQC/FEMesh.h
C:/Users/Brig/Documents/ShapeWorksStudio/src/Surfworks/PreViewMeshQC/FEMesh.cpp

Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Member Function Documentation