#include "Cell.h"
#include <iostream>
#include <math.h>
#include <algorithm>
#include "CRConnectivity.h"
#include "Quad.h"
#include "Tri.h"
#include "Hex.h"
#include "Tet.h"
#include "Pyramid.h"
#include "Prism.h"
#include "StorageSite.h"

Include dependency graph for Cell.cpp:

Classes
struct	MyCoords

Functions
bool	myCoordComparison (const MyCoords &a, const MyCoords &b)

void	orderCellFacesAndNodes (CRConnectivity &cellFaces, CRConnectivity &cellNodes, const CRConnectivity &faceNodes, const CRConnectivity &faceCells, const Array< Vector< double, 3 > > &nodeCoordinates)

Variables
static Cell< Quad >	quad

static Cell< Tri >	tri

static Cell< Hex >	hexCell

static Cell< Tet >	tetCell

static Cell< Pyramid >	pyramidCell

static Cell< Prism >	prismCell

Function Documentation

bool myCoordComparison	(	const MyCoords &	a,
		const MyCoords &	b
	)

Definition at line 235 of file Cell.cpp.

References MyCoords::x.

Referenced by orderCellFacesAndNodes().

 {
   return (a.x<b.x);
 }

void orderCellFacesAndNodes	(	CRConnectivity &	cellFaces,
		CRConnectivity &	cellNodes,
		const CRConnectivity &	faceNodes,
		const CRConnectivity &	faceCells,
		const Array< Vector< double, 3 > > &	nodeCoordinates
	)

Definition at line 241 of file Cell.cpp.

References CRConnectivity::getCount(), CRConnectivity::getRowSite(), StorageSite::getSelfCount(), hexCell, myCoordComparison(), prismCell, pyramidCell, quad, tetCell, and tri.

Referenced by Mesh::getCellNodes().

 {
 
   const int numCells = cellNodes.getRowSite().getSelfCount();
 
   for(int c=0; c<numCells; c++)
   {
       const int numCellNodes = cellNodes.getCount(c);
       const int numCellFaces = cellFaces.getCount(c);
 
       int edgeFaceCount  =0;
       int triFaceCount = 0;
       int quadFaceCount = 0;
       for(int nf=0; nf<numCellFaces; nf++)
       {
           const int f = cellFaces(c,nf);
           const int faceNodeCount = faceNodes.getCount(f);
           switch(faceNodeCount)
           {
           case 2:
             edgeFaceCount++;
             break;
           case 3:
             triFaceCount++;
             break;
           case 4:
             quadFaceCount++;
             break;
           default:
             break;
           }
       }
 
       if (numCellNodes == 4 && edgeFaceCount == 4)
       {
           quad.orderCellFacesAndNodes(c,cellFaces,cellNodes,
                                       faceNodes,faceCells,nodeCoordinates);
       }
       else if (numCellNodes == 3 && edgeFaceCount == 3)
       {
           tri.orderCellFacesAndNodes(c,cellFaces,cellNodes,
                                      faceNodes,faceCells,nodeCoordinates);
       }
       else if (numCellNodes == edgeFaceCount)
       {
           vector<MyCoords> angles;
           Vector<double,3> mean(Vector<double,3>::getZero());
           for(int nn=0; nn<numCellNodes; nn++)
             mean += nodeCoordinates[cellNodes(c,nn)];
           mean /= numCellNodes;
           for(int nn=0; nn<numCellNodes; nn++)
           {
               const int nodeIndex = cellNodes(c,nn);
               const Vector<double,3> xm =
                 nodeCoordinates[nodeIndex] - mean;
               const double angle = atan2(xm[1], xm[0]);
               angles.push_back(MyCoords(nodeIndex,angle));
           }
 
           sort(angles.begin(),angles.end(),myCoordComparison);
           
           for(int nn=0; nn<numCellNodes; nn++)
           {
               cellNodes(c,nn) = angles[nn].i;
           }
       }
       else if (numCellNodes == 8 && quadFaceCount == 6)
       {
           hexCell.orderCellFacesAndNodes(c,cellFaces,cellNodes,
                                          faceNodes,faceCells,nodeCoordinates);
       }
       else if (numCellNodes == 4 && triFaceCount == 4)
       {
           tetCell.orderCellFacesAndNodes(c,cellFaces,cellNodes,
                                          faceNodes,faceCells,nodeCoordinates);
       }
       else if (numCellNodes == 5 && triFaceCount == 4 &&
                quadFaceCount == 1)
       {
           pyramidCell.orderCellFacesAndNodes(c,cellFaces,cellNodes,
                                              faceNodes,faceCells,
                                              nodeCoordinates);
       }
       else if (numCellNodes == 6 && triFaceCount == 2 &&
                quadFaceCount == 3)
       {
           prismCell.orderCellFacesAndNodes(c,cellFaces,cellNodes,
                                            faceNodes,faceCells,
                                            nodeCoordinates);
       }
       else
       {
 #if 0
           cerr << "unimplemented cell type: numCellnodes = "
                << numCellNodes
                << " quadFaceCount = " << quadFaceCount
                << " triFaceCount = " << triFaceCount
                << " edgeFaceCount = " << edgeFaceCount
                << endl;
 #endif
       }
   }
 }