CellMark.h File Reference

#include "Field.h"
#include "MultiField.h"
#include "MultiFieldMatrix.h"
#include "Mesh.h"
#include "StorageSite.h"
#include "FlowFields.h"
#include "GeomFields.h"
#include "Vector.h"
#include "NumType.h"
#include "Octree.h"
#include "CRConnectivity.h"
#include "Array.h"

Include dependency graph for CellMark.h:

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

Go to the source code of this file.

Typedefs
typedef Vector< double, 3 >	VecD3
typedef Array< VecD3 >	VecD3Array

Functions
int	inCell (const int cellIndex, const Vector< double, 3 > &point, const CRConnectivity &faceCells, const CRConnectivity &cellFaces, const VecD3Array &faceArea, const VecD3Array &faceCentroid)
void	reportCellMark (const Mesh &mesh, const int nCells, const VecD3Array &cellCentroid, const string fileBase)
void	markCell (Mesh &mesh, const int nCells, const int nSelfCells, const CRConnectivity &cellParticles, const CRConnectivity &cellCells)
const shared_ptr< CRConnectivity >	setParticleCells (const StorageSite &rowSite, const StorageSite &colSite, const Array< int > &connectivity)
const shared_ptr< CRConnectivity >	setibFaceCells (const Mesh &mesh, const Array< int > &ibFaceGroup, const StorageSite &ibFaces, const StorageSite &cells, const CRConnectivity &faceCells, const CRConnectivity &cellFaces, const VecD3Array &faceCentroid)
const shared_ptr< CRConnectivity >	setibFaceParticles (const Mesh &mesh, const StorageSite &ibFaces, const Array< int > &ibFaceGroup, const StorageSite &particles, const CRConnectivity &faceCells, const CRConnectivity &cellParticles, const CRConnectivity &cellCells, const Array< int > &particleTyp)
void	markIBFaces (Mesh &mesh, const int nCells, const CRConnectivity &faceCells)
void	checkIBFaces (const Array< int > &ibFaceList, const VecD3Array &faceArea, const CRConnectivity &faceCells, const Mesh &mesh)

Typedef Documentation

typedef Vector<double, 3> VecD3

Definition at line 22 of file CellMark.h.

typedef Array<VecD3> VecD3Array

Definition at line 23 of file CellMark.h.

Function Documentation

void checkIBFaces	(	const Array< int > &	ibFaceList,
		const VecD3Array &	faceArea,
		const CRConnectivity &	faceCells,
		const Mesh &	mesh
	)

int inCell	(	const int	cellIndex,
		const Vector< double, 3 > &	point,
		const CRConnectivity &	faceCells,
		const CRConnectivity &	cellFaces,
		const VecD3Array &	faceArea,
		const VecD3Array &	faceCentroid
	)

void markCell	(	Mesh &	mesh,
		const int	nCells,
		const int	nSelfCells,
		const CRConnectivity &	cellParticles,
		const CRConnectivity &	cellCells
	)

Definition at line 77 of file CellMark.cpp.

References CRConnectivity::getCount(), Mesh::IBTYPE_BOUNDARY, Mesh::IBTYPE_FLUID, and Mesh::IBTYPE_SOLID.

Referenced by CellMark_Impl().

{

  //step 1: Mark the cells with solid particles as solid
  //and Mark the cells with no solid particles as fluid

   for(int c=0; c<nCells; c++){
     const int particleCount = cellParticles.getCount(c);
     //if no particle in cell, mark as fluid
     if (particleCount == 0) {
       mesh.setIBTypeForCell(c,Mesh::IBTYPE_FLUID);
     }
     //if has particle in cell, mark as solid
     else { mesh.setIBTypeForCell(c,Mesh::IBTYPE_SOLID); }
   }
   //step2: in solid cells, mark cells with no fluid neighbors as solid
   //and mark cells with at least one fluid neighbors as IB cells

    for (int c=0; c<nCells; c++){
      const int ibType = mesh.getIBTypeForCell(c);
      int flag;
      //search all solid cells
      if(ibType == Mesh::IBTYPE_SOLID){
        flag=1;  //true for solid cells
        const int ncNumber=cellCells.getCount(c);
        for(int nc=0; nc<ncNumber; nc++){
          const int cellIndex=cellCells(c,nc);
           if(mesh.getIBTypeForCell(cellIndex)==Mesh::IBTYPE_FLUID && cellIndex < nSelfCells){ 
             //if(mesh.getIBTypeForCell(cellIndex)==Mesh::IBTYPE_FLUID){
            flag=0;   
          }
        }
        //if solid cell has at least one fluid cell neighbor, mark as IBM type
        if(flag==0) mesh.setIBTypeForCell(c,Mesh::IBTYPE_BOUNDARY);
      }
    }
   
}

void markIBFaces	(	Mesh &	mesh,
		const int	nCells,
		const CRConnectivity &	faceCells
	)

Definition at line 166 of file CellMark.cpp.

References Mesh::getIBFaces(), Mesh::IBTYPE_BOUNDARY, Mesh::IBTYPE_FLUID, and StorageSite::setCount().

Referenced by CellMark_Impl().

{
  //definition of ibFaces: the faces between IB cells and Fluid cells
  //first, count the number of ibFaces
    int ibFaceCount=0;
    for(int f=0; f<nFaces; f++){
      const int c0 = faceCells(f, 0);
      const int c1 = faceCells(f, 1);
      const int type0 = mesh.getIBTypeForCell(c0);
      const int type1 = mesh.getIBTypeForCell(c1);
      if(type0 == Mesh::IBTYPE_FLUID && type1 ==  Mesh::IBTYPE_BOUNDARY)
        ibFaceCount++;
      if(type1 == Mesh::IBTYPE_FLUID && type0 ==  Mesh::IBTYPE_BOUNDARY)
        ibFaceCount++;
    }
    cout<<"ibFaceCount is "<<ibFaceCount<<endl;
      
    //then, allocate an array for ibFace
    mesh.createIBFaceList(ibFaceCount);

    //insert the entries to ibface array
    ibFaceCount=0;
    for(int f=0; f<nFaces; f++){
      const int c0 = faceCells(f, 0);
      const int c1 = faceCells(f, 1);
      const int type0 = mesh.getIBTypeForCell(c0);
      const int type1 = mesh.getIBTypeForCell(c1);
      if(type0 == Mesh::IBTYPE_FLUID && type1 ==  Mesh::IBTYPE_BOUNDARY){
        mesh.addIBFace(ibFaceCount, f);
        ibFaceCount++;
      }
      if(type1 == Mesh::IBTYPE_FLUID && type0 ==  Mesh::IBTYPE_BOUNDARY){
        mesh.addIBFace(ibFaceCount, f);
        ibFaceCount++;
      }
    }


    //initialize storagesite ibFaces
    StorageSite&  ibFaces = mesh.getIBFaces();
    ibFaces.setCount(ibFaceCount);

}

void reportCellMark	(	const Mesh &	mesh,
		const int	nCells,
		const VecD3Array &	cellCentroid,
		const string	fileBase
	)

const shared_ptr<CRConnectivity> setibFaceCells	(	const Mesh &	mesh,
		const Array< int > &	ibFaceGroup,
		const StorageSite &	ibFaces,
		const StorageSite &	cells,
		const CRConnectivity &	faceCells,
		const CRConnectivity &	cellFaces,
		const VecD3Array &	faceCentroid
	)

Definition at line 357 of file CellMark.cpp.

References StorageSite::getCount(), CRConnectivity::getCount(), and Mesh::IBTYPE_FLUID.

Referenced by CellMark_Impl().

{

  shared_ptr<CRConnectivity> ibFaceCells (new CRConnectivity (ibFaces, cells));
  int maxcount=0;
  //initCount: new Array for row
  (*ibFaceCells).initCount();
  
  const int rowSize = ibFaces.getCount();

 
  //search level = 1, search only one fluid cell adjacent to IBface
  //search level = 2, search two levels of fluid cell neighborhood of the ibface
  const int searchLevel = 2 ;

  //specify the number of nonzeros for each row
 

  for(int p=0; p<rowSize; p++){
    const int IBfaceIndex = ibFaceList [p];
    int count=0;
    //find the fluid cells next to ibface
   
    int C0 = faceCells(IBfaceIndex, 0);      
    const int cellType = mesh.getIBTypeForCell(C0);
    if (cellType != Mesh::IBTYPE_FLUID){
      C0 = faceCells(IBfaceIndex,1);
    }
    count ++;
    if(searchLevel == 2){   
        
      const int nf = cellFaces.getCount(C0);
      for(int f=0; f<nf; f++){
        const int faceID = cellFaces(C0, f);
        if (faceID != IBfaceIndex){
          const int CC0 = faceCells(faceID,0);
          const int CC1 = faceCells(faceID,1);
          if(CC0 != C0 && mesh.getIBTypeForCell(CC0) == Mesh::IBTYPE_FLUID){
            count++;
          }
          if(CC1 != C0 && mesh.getIBTypeForCell(CC1) == Mesh::IBTYPE_FLUID){
            count++;
          }
        }
      }
    }
       
    (*ibFaceCells).addCount(p, count);   
    if (count>=maxcount)
      maxcount=count;
  }
    
  cout<<"max Cell neibhbors  "<<maxcount<<endl;
  
  //finishCount: allocate col array and reset row array
  //ready to get the entries for nonzeros
  (*ibFaceCells).finishCount();

  //add in the entries for each row
  for(int p=0; p<rowSize; p++){
    const int IBfaceIndex = ibFaceList [p];
    vector<int> cellIndexList;
    int C0 = faceCells(IBfaceIndex, 0);      
    const int cellType = mesh.getIBTypeForCell(C0);
    if (cellType != Mesh::IBTYPE_FLUID){
      C0 = faceCells(IBfaceIndex,1);
    }
    (*ibFaceCells).add(p, C0);

    if(searchLevel == 2){   
      const int nf = cellFaces.getCount(C0);
      for(int f=0; f<nf; f++){
        const int faceID = cellFaces(C0, f);
        if (faceID != IBfaceIndex){
          const int CC0 = faceCells(faceID,0);
          const int CC1 = faceCells(faceID,1);
          if(CC0 != C0 && mesh.getIBTypeForCell(CC0) == Mesh::IBTYPE_FLUID){
            (*ibFaceCells).add(p, CC0);
          }
          if(CC1 != C0 && mesh.getIBTypeForCell(CC1) == Mesh::IBTYPE_FLUID){
            (*ibFaceCells).add(p, CC1);;
          }
        }
      }
    }
  }
  (*ibFaceCells).finishAdd();
  
  return (ibFaceCells);
}

const shared_ptr<CRConnectivity> setibFaceParticles	(	const Mesh &	mesh,
		const StorageSite &	ibFaces,
		const Array< int > &	ibFaceGroup,
		const StorageSite &	particles,
		const CRConnectivity &	faceCells,
		const CRConnectivity &	cellParticles,
		const CRConnectivity &	cellCells,
		const Array< int > &	particleTyp
	)

Definition at line 243 of file CellMark.cpp.

References StorageSite::getCount(), CRConnectivity::getCount(), and Mesh::IBTYPE_BOUNDARY.

Referenced by CellMark_Impl().

{

  //CR connectivity cellParticles includes all the particles located in each cell
  //here, we want to create ibFace to Particles in which only the surface particles are counted in
  //surface particles are identified by particle type 1
                                               
  shared_ptr<CRConnectivity> ibFaceParticles (new CRConnectivity (ibFaces, particles));
  int maxcount = 0;
  int mincount = 1000;
  //initCount: new Array for row
  (*ibFaceParticles).initCount();
  const int rowSize = ibFaces.getCount();

  //specify the number of nonzeros for each row
  
  for(int p=0; p<rowSize; p++){
    const int faceIndex = ibFaceList [p];
    int C0 = faceCells(faceIndex, 0);
    int C1 = faceCells(faceIndex, 1);

    if (mesh.getIBTypeForCell(C1) == Mesh::IBTYPE_BOUNDARY)     
      {  C0 = C1; }
    //C0 is IBtype, C1 is fluid
   
    int nP = cellParticles.getCount(C0);
    int count=0;
    for(int n=0; n<nP; n++){
      int pID = cellParticles(C0, n);
      if(particleType[pID] == 1){
        count++;
      }
    }
#if 1
    //assuming only one fluid cell is used in interpolation, then at least three particles are needed to 
    //apply the linear least square method. If the current IB cell has less than three particles, then search 
    //neighbors for more particles
    if(count < 3){
      const int nbSize = cellCells.getCount(C0);
      for(int c=0; c < nbSize; c++){
        int cnb = cellCells(C0, c);
        nP = cellParticles.getCount(cnb);
        for (int n=0; n<nP; n++){
          int pID = cellParticles(cnb, n);
          if(particleType[pID] == 1){
            count++;
          }
        } 
      }
    }
#endif

    if(count>=maxcount)         maxcount=count;   
    if(count<=mincount)         mincount=count;
    
    (*ibFaceParticles).addCount(p, count);      
     
  }

  cout<<"max count of particles in IB Cells is "<<maxcount<<endl;
  cout<<"min count of particles in IB Cells is "<<mincount<<endl;
  //finishCount: allocate col array and reset row array
  //ready to get the entries for nonzeros
  (*ibFaceParticles).finishCount();

  //add in the entries for each row
  for(int p=0; p<rowSize; p++){
    const int faceIndex = ibFaceList [p];
    int C0 = faceCells(faceIndex, 0);
    int C1 = faceCells(faceIndex, 1);

    if (mesh.getIBTypeForCell(C1) == Mesh::IBTYPE_BOUNDARY)     
      {  C0 = C1; }
    //C0 is IBtype, C1 is fluid
    int count=0;
    int nP = cellParticles.getCount(C0);
    for(int n=0; n<nP; n++){
      int pID=cellParticles(C0,n);
      if(particleType[pID] == 1){
        count++;
        (*ibFaceParticles).add(p, pID);
      }
    }
#if 1  
    if(count < 3){
      const int nbSize = cellCells.getCount(C0);
      for(int c=0; c < nbSize; c++){
        int cnb = cellCells(C0, c);
        nP = cellParticles.getCount(cnb);
        for (int n=0; n<nP; n++){
          int pID = cellParticles(cnb, n);
          if(particleType[pID] == 1){
            (*ibFaceParticles).add(p, pID);
          }
        }
      }
    }
#endif

  }

  (*ibFaceParticles).finishAdd();
  
  return(ibFaceParticles);
}

const shared_ptr<CRConnectivity> setParticleCells	(	const StorageSite &	rowSite,
		const StorageSite &	colSite,
		const Array< int > &	connectivity
	)

Definition at line 456 of file CellMark.cpp.

References StorageSite::getCount().

Referenced by CellMark_Impl().

{
  const int rowSize = rowSite.getCount();
  //  const int colSize = colSite.getCount();

  shared_ptr<CRConnectivity> rowCol (new CRConnectivity (rowSite, colSite));

  //initCount: new Array for row
  (*rowCol).initCount();

  //specify the number of nonzeros for each row
  //here, each solid point only has connectivity with one cell
  //so for each row, it has only one nonzero
  for(int p=0; p<rowSize; p++){
    int value = connectivity[p];
    if (value != -1)
      (*rowCol).addCount(p, 1);
  }

  //finishCount: allocate col array and reset row array
  //ready to get the entries for nonzeros
  (*rowCol).finishCount();

  //add in the entries for each row
  for(int p=0; p<rowSize; p++){
    int value = connectivity[p];
    if (value != -1)
      (*rowCol).add(p, value);
  }

  (*rowCol).finishAdd();
  return(rowCol);

}