Grid Class Reference

#include <Grid.h>

Collaboration diagram for Grid:

Public Member Functions
	Grid (GeomFields &geomFields, FlowFields &flowFields, string coordFileName, string velocityFileName)
	~Grid ()
const shared_ptr< Array< VecD3 > > &	getCoordinates ()
const shared_ptr< Array< VecD3 > > &	getVelocities ()
const StorageSite &	getNodes ()
const StorageSite &	getCells ()
void	setandwriteGrids (const string fileBase)
void	createCellToNodeConnectivity ()
void	setConnFaceToGrid (Mesh &mesh, const StorageSite &faces)
vector< int >	findNeighbors (const VecD3 &point)
	!! only applicable for rectangular mesh More...
const shared_ptr< CRConnectivity >	createConnectivity (const StorageSite &pointSite, const VecD3Array &points)
shared_ptr< ArrayBase >	computeInterpolatedVelocity (const StorageSite &faces)
vector< int >	findNeighborsByCells (const VecD3 &point)

Protected Attributes
GeomFields &	_geomFields
FlowFields &	_flowFields
StorageSite	_nodes
StorageSite	_cells
shared_ptr< Array< VecD3 > >	_coordinates
shared_ptr< Array< VecD3 > >	_velocities
shared_ptr< CRConnectivity >	_cellNodes

Detailed Description

Definition at line 25 of file Grid.h.

Constructor & Destructor Documentation

Grid::Grid	(	GeomFields &	geomFields,
		FlowFields &	flowFields,
		string	coordFileName,
		string	velocityFileName
	)

Definition at line 33 of file Grid.cpp.

References _coordinates, _nodes, _velocities, Field::addArray(), GeomFields::coordinate, createCellToNodeConnectivity(), findNeighborsByCells(), StorageSite::getCount(), readVectors(), StorageSite::setCount(), and FlowFields::velocity.

                                   :
  _geomFields(geomFields),
  _flowFields(flowFields),
  _nodes(0),
  _cells(0),
  _coordinates(),
  _velocities()
{

    //set up grid data//  
  //grid.setandwriteGrids(fileBase);

  //read grid coordinates

  _coordinates = readVectors(coordFileName.c_str());

  //read grid velocity
  _velocities = readVectors(velocityFileName.c_str());

  _nodes.setCount(_velocities->getLength());

  //store coordinates in geomField
  geomFields.coordinate.addArray(_nodes, _coordinates);

  //store velocity in flowField
  flowFields.velocity.addArray(_nodes, _velocities);

  // create cell to node connectivity
  createCellToNodeConnectivity();

#if 0
  //test findCells using single point
  VecD3 point;
  point[0]=0.;
  point[1]=0.6;
  point[2]=0.0;
  const StorageSite& gridCells = grid.getCells();
  
  const int nGridCells = gridCells.getCount();

  const CRConnectivity& cellToGrids = mesh.getConnectivity(gridCells, grids);

  vector<int> nb = findNeighborsByCells(point, (*Grid_Coordinates), nGridCells, cellToGrids);
  for(int n=0; n<nb.size();n++){
      cout<<"point is in cell "<<nb[n]<<endl;
  }
#endif
}

Grid::~Grid

(

)

Definition at line 83 of file Grid.cpp.

{ }

Member Function Documentation

shared_ptr< ArrayBase > Grid::computeInterpolatedVelocity

(

const StorageSite &

faces

)

Definition at line 411 of file Grid.cpp.

References _geomFields, GeomFields::_interpolationMatrices, _nodes, _velocities, and StorageSite::getCount().

{
  typedef CRMatrixTranspose<double,double,double> IMatrix;
  typedef CRMatrixTranspose<double,VecD3,VecD3> IMatrixV3;


  const int nFaces = faces.getCount();
    
    
  GeomFields::SSPair key(&faces,&_nodes);
  const IMatrix& mIC =
    dynamic_cast<const IMatrix&> (*(_geomFields._interpolationMatrices[key]));

  IMatrixV3 mICV(mIC);
          
  shared_ptr<VecD3Array> faceV(new VecD3Array(nFaces));
          
  faceV->zero();

  mICV.multiplyAndAdd(*faceV,*_velocities);

  return (faceV);
      
}

void Grid::createCellToNodeConnectivity

(

)

Definition at line 151 of file Grid.cpp.

References _cellNodes, _cells, _nodes, and StorageSite::setCount().

Referenced by Grid().

{
  const int nXGrid = 7;
  const int nYGrid = 3;

  //init storagesite for cells
  const int nGridCells = (nXGrid-1)*(nYGrid-1)*2;
  _cells.setCount(nGridCells);

  //create cell to grids connectivity
  //since it is tri cell, each cell connects to 3 grid points
  _cellNodes = shared_ptr<CRConnectivity>(new CRConnectivity (_cells, _nodes));
  (*_cellNodes).initCount();
  for (int n=0; n<nGridCells; n++){
      (*_cellNodes).addCount(n, 3);
  }
  (*_cellNodes).finishCount();
  int node1, node2, node3; 
  int id = 0;
  for (int n=0; n<nGridCells/2; n+=2){
      node1 = id;
      node2 = id+1;
      node3 = id+4;
      (*_cellNodes).add(n, node1);
      (*_cellNodes).add(n, node2);
      (*_cellNodes).add(n, node3);
      node1 = id;
      node2 = id+4;
      node3 = id+3;
      (*_cellNodes).add(n+1, node1);
      (*_cellNodes).add(n+1, node2);
      (*_cellNodes).add(n+1, node3);
      id+=3;
  }
  id = 1;
  for (int n=nGridCells/2; n<nGridCells;  n+=2){
      node1 = id;
      node2 = id+1;
      node3 = id+4;
      (*_cellNodes).add(n, node1);
      (*_cellNodes).add(n, node2);
      (*_cellNodes).add(n, node3);
      node1 = id;
      node2 = id+4;
      node3 = id+3;
      (*_cellNodes).add(n+1, node1);
      (*_cellNodes).add(n+1, node2);
      (*_cellNodes).add(n+1, node3);
      id+=3;
  }
  
  (*_cellNodes).finishAdd();

}

const shared_ptr< CRConnectivity > Grid::createConnectivity	(	const StorageSite &	pointSite,
		const VecD3Array &	points
	)

Definition at line 363 of file Grid.cpp.

References _nodes, findNeighborsByCells(), and StorageSite::getCount().

Referenced by setConnFaceToGrid().

{
  shared_ptr<CRConnectivity> pointToNodes (new CRConnectivity (pointSite, _nodes));

  (*pointToNodes).initCount();

  const int nPoints = pointSite.getCount();
  
  for(int i=0; i<nPoints; i++){
   
      vector<int> neighborList = findNeighborsByCells(points[i]);
      int count = neighborList.size();
      if(count!=0)     
        (*pointToNodes).addCount(i, count);
  }
    
  (*pointToNodes).finishCount();

  for(int i=0; i<nPoints; i++){
      vector<int> neighborList = findNeighborsByCells(points[i]);
      int count = neighborList.size();
      for(int j=0; j<count; j++){
          (*pointToNodes).add(i, neighborList[j]);
      }
  }
  (*pointToNodes).finishAdd();

  return(pointToNodes);

}

vector< int > Grid::findNeighbors

(

const VecD3 &

point

)

!! only applicable for rectangular mesh

Definition at line 291 of file Grid.cpp.

References _coordinates, and Array< T >::getLength().

{
  const Array<VecD3>& nodeCoords = *_coordinates;
  const int nNodes = nodeCoords.getLength();
  
  vector<int> neighborList;

  //first, judge if this point falls into nodeCoords
  //if not, return NULL vector
  //if yes, continue to find the neighbors
  Vector<int,3> mFlag, pFlag;
  mFlag=pFlag=0;
  
  for (int i=0; i<nNodes; i++){
      for(int k=0; k<3; k++){
          if(point[k]<nodeCoords[i][k]) {
              mFlag[k]++;
          }
          if (point[k]>nodeCoords[i][k]) {
              pFlag[k]++;
          }
      }
  }
 

  if(mFlag[0]==nNodes||mFlag[1]==nNodes||mFlag[2]==nNodes||pFlag[0]==nNodes||pFlag[1]==nNodes||pFlag[2]==nNodes)
    return (neighborList);

  else{  
   
      VecD3 pLimit, mLimit, allow, dR;
      for(int k=0; k<3; k++){
          pLimit[k]=1e10;
          mLimit[k]=-1e10;
          allow[k]=1.e-8;
          dR[k]=0.0;
      }
      //find the bounds for point
      for(int i=0; i<nNodes; i++){
          dR = point - nodeCoords[i];
          for(int k=0; k<3; k++){
              if( dR[k]<=0.0 && dR[k]>mLimit[k] ){
                  mLimit[k]=dR[k];
              }
              if (dR[k]>=0.0 && dR[k]<pLimit[k]){
                  pLimit[k]=dR[k];
              }
          }
      }
    
      //find who bounds the point
  
      for(int i=0; i<nNodes; i++){
          if(nodeCoords[i][0]>(point[0]-pLimit[0]-allow[0])&& nodeCoords[i][0]<(point[0]-mLimit[0]+allow[0])){
              if(nodeCoords[i][1]>(point[1]-pLimit[1]-allow[1])&& nodeCoords[i][1]<(point[1]-mLimit[1]+allow[1])){
                  if(nodeCoords[i][2]>(point[2]-pLimit[2]-allow[2])&& nodeCoords[i][2]<(point[2]-mLimit[2]+allow[2])){
                      neighborList.push_back(i);
                  }
              }
          }
      }

      return(neighborList);
  }

}

vector< int > Grid::findNeighborsByCells

(

const VecD3 &

point

)

Definition at line 209 of file Grid.cpp.

References _cellNodes, _cells, _coordinates, dot(), StorageSite::getCount(), CRConnectivity::getCount(), and mag().

Referenced by createConnectivity(), and Grid().

{
  vector<int> neighborList;
  const int nCells = _cells.getCount();
  const CRConnectivity& cellNodes = *_cellNodes;
  const Array<VecD3>& nodeCoords = *_coordinates;
  
  for ( int c=0; c<nCells; c++){
    const int nsize = cellNodes.getCount(c);
    int node[nsize];
    for(int n=0; n<nsize; n++){
      node[n] = cellNodes(c,n);
    }
    Array<VecD3> faceArea(nsize);
    Array<VecD3> faceCentroid(nsize);
    for(int n=0; n<nsize-1; n++){
      faceArea[n]=nodeCoords[node[n+1]]-nodeCoords[node[n]];
      faceCentroid[n]=(nodeCoords[node[n+1]]+nodeCoords[node[n]])/2.;
    }
    faceArea[nsize-1]=nodeCoords[node[0]]-nodeCoords[node[nsize-1]];
    faceCentroid[nsize-1]=(nodeCoords[node[0]]+nodeCoords[node[nsize-1]])/2.;
    
    int find = 1;
    for(int n=0; n<nsize; n++){
      VecD3 faceNorm;
      faceNorm[0]=faceArea[n][1];
      faceNorm[1]=-faceArea[n][0];
      faceNorm[2]=faceArea[n][2];

      VecD3 dr = point - faceCentroid[n];
      dr[2] = 0.0;  //difference in z direction is neglected. just check x-y plane
      if (dot(faceNorm,dr) > 0.0) {
        find = 0;
        break;
      }
    }
    //point falls into a cell
    if (find){
      for(int n=0; n<nsize; n++){
        node[n]=cellNodes(c,n);
        neighborList.push_back(node[n]);
      }
      return(neighborList);
    }
  }

  //point falls outside of grid boundary
  //find the cloest cell to this point
  //use that cell to interpolate

  double distMin = 1.0e10;
  int closestCell = 0; 
  for ( int c=0; c<nCells; c++){
    const int nsize = cellNodes.getCount(c);
    VecD3 cellCentroid;
    cellCentroid[0]=0.0;
    cellCentroid[1]=0.0;
    cellCentroid[2]=0.0;
    for(int n=0; n<nsize; n++){
      cellCentroid += nodeCoords[cellNodes(c,n)];
    }
    cellCentroid /= 3.;
    VecD3 dr = point - cellCentroid;
    double distance = mag(dr);
    if(distance < distMin){
      distMin = distance; 
      closestCell = c;
    }
  }
  const int nsize = cellNodes.getCount(closestCell);
  for(int n=0; n<nsize; n++){
    neighborList.push_back(cellNodes(closestCell,n));
  }
  return(neighborList);
}

const StorageSite& Grid::getCells ( )

inline

Definition at line 38 of file Grid.h.

References _cells.

{return _cells;}

const shared_ptr<Array<VecD3> >& Grid::getCoordinates ( )

inline

Definition at line 33 of file Grid.h.

References _coordinates.

{return  _coordinates;}

const StorageSite& Grid::getNodes ( )

inline

Definition at line 37 of file Grid.h.

References _nodes.

{return _nodes;}

const shared_ptr<Array<VecD3> >& Grid::getVelocities ( )

inline

Definition at line 35 of file Grid.h.

References _velocities.

{return  _velocities;}

void Grid::setandwriteGrids

(

const string

fileBase

)

Definition at line 85 of file Grid.cpp.

{
 
  int nX=7, nY=3, nZ=1;
  double gapX=1.4/nX, gapY=1.2/nY, gapZ=0.0/nZ;
    
  VecD3 center;
  center[0]=0.501;
  center[1]=0.501;
  center[2]=0.0;

  int count=0;
  VecD3 gridCoord[nX*nY*nZ];
  VecD3 gridVelocity[nX*nY*nZ];

  //set up grid coordinate
  for(int i=0; i<nX; i++){
      for(int j=0; j<nY; j++){
          for(int k=0; k<nZ; k++){
              gridCoord[count][0]=i*gapX-0.023;//+(center[0]-(nX*gapX/2.));
              gridCoord[count][1]=-j*gapY+0.92;//+(center[1]-(nY*gapY/2.));
              gridCoord[count][2]=k*gapZ;
              count+=1;
          }
      }
  }

  //set up grid velocity
  const double vMax=1.0;
  const double vMin=0.0;
  const double vGap=(vMax-vMin)/nX;
  count=0;
  for(int i=0; i<nX; i++){
      for(int j=0; j<nY; j++){
          for(int k=0; k<nZ; k++){
              gridVelocity[count][0]=vMin+vGap*i;
              gridVelocity[count][1]=0.0;
              gridVelocity[count][2]=0.0;
              count++;
          }
      }
  }
  //write out coordinate into file
  string fileName1=fileBase+"Grid_Coord.dat";
  char* file1;
  file1=&fileName1[0];
  FILE *fp1=fopen(file1,"w");
  fprintf(fp1,"%i\n",count);
  for(int p=0; p<count; p++){
      fprintf(fp1, "%lf\t%lf\t%lf\n", gridCoord[p][0], gridCoord[p][1], gridCoord[p][2]);
  } 
  fclose(fp1);

  //write out velocity into file
  string fileName2=fileBase+"Grid_Velocity.dat";
  char* file2;
  file2=&fileName2[0];
  FILE *fp2=fopen(file2,"w");
  fprintf(fp2,"%i\n",count);
  for(int p=0; p<count; p++){
      fprintf(fp2, "%lf\t%lf\t%lf\n", gridVelocity[p][0],gridVelocity[p][1],gridVelocity[p][2]);
  }     
  fclose(fp2);
}

void Grid::setConnFaceToGrid	(	Mesh &	mesh,
		const StorageSite &	faces
	)

Definition at line 397 of file Grid.cpp.

References _geomFields, _nodes, GeomFields::coordinate, createConnectivity(), and Mesh::setConnectivity().

{
  const VecD3Array& faceCentroid = 
    dynamic_cast<const VecD3Array& > (_geomFields.coordinate[faces]);
  
  shared_ptr<CRConnectivity> faceGridsCR = 
    createConnectivity(faces, faceCentroid);
 
  mesh.setConnectivity(faces, _nodes, faceGridsCR);
}

Member Data Documentation

shared_ptr<CRConnectivity> Grid::_cellNodes

protected

Definition at line 66 of file Grid.h.

Referenced by createCellToNodeConnectivity(), and findNeighborsByCells().

StorageSite Grid::_cells

protected

Definition at line 63 of file Grid.h.

Referenced by createCellToNodeConnectivity(), findNeighborsByCells(), and getCells().

shared_ptr<Array<VecD3> > Grid::_coordinates

protected

Definition at line 64 of file Grid.h.

Referenced by findNeighbors(), findNeighborsByCells(), getCoordinates(), and Grid().

FlowFields& Grid::_flowFields

protected

Definition at line 61 of file Grid.h.

GeomFields& Grid::_geomFields

protected

Definition at line 60 of file Grid.h.

Referenced by computeInterpolatedVelocity(), and setConnFaceToGrid().

StorageSite Grid::_nodes

protected

Definition at line 62 of file Grid.h.

Referenced by computeInterpolatedVelocity(), createCellToNodeConnectivity(), createConnectivity(), getNodes(), Grid(), and setConnFaceToGrid().

shared_ptr<Array<VecD3> > Grid::_velocities

protected

Definition at line 65 of file Grid.h.

Referenced by computeInterpolatedVelocity(), getVelocities(), and Grid().

---

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

• Grid.h
• Grid.cpp