Cell.h File Reference

#include <map>
#include "Array.h"
#include "Vector.h"

Include dependency graph for Cell.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
class	Cell< CellTrait >

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

Function Documentation

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