#include <MomentumPressureGradientDiscretization.h>

Inheritance diagram for MomentumPressureGradientDiscretization< X >:

Collaboration diagram for MomentumPressureGradientDiscretization< X >:

Public Types
typedef NumTypeTraits< X > ::T_Scalar	T_Scalar

typedef MatrixTraitHelper< X > ::T_Matrix	CCMatrix

typedef Gradient< X >	XGrad

typedef GradientMatrix< X >	GradMatrix

typedef GradMatrix::Coord	VPCoeff

typedef Array< X >	XArray

typedef Array< T_Scalar >	TArray

typedef Vector< T_Scalar, 3 >	VectorT3

typedef Array< VectorT3 >	VectorT3Array

typedef Array< XGrad >	GradArray

Public Member Functions
	MomentumPressureGradientDiscretization (const MeshList &meshes, const GeomFields &geomFields, FlowFields &flowFields, GradientModel< X > &pressureGradientModel)

void	discretize (const Mesh &mesh, MultiFieldMatrix &mfmatrix, MultiField &, MultiField &rField)

Public Member Functions inherited from Discretization
	Discretization (const MeshList &meshes)

virtual	~Discretization ()

	DEFINE_TYPENAME ("Discretization")

Private Attributes
const GeomFields &	_geomFields

FlowFields &	_flowFields

GradientModel< X > &	_pressureGradientModel

Additional Inherited Members
Protected Attributes inherited from Discretization
const MeshList &	_meshes

Detailed Description

template<class X>
class MomentumPressureGradientDiscretization< X >

Definition at line 26 of file MomentumPressureGradientDiscretization.h.

Member Typedef Documentation

template<class X >

typedef MatrixTraitHelper<X>::T_Matrix MomentumPressureGradientDiscretization< X >::CCMatrix

Definition at line 32 of file MomentumPressureGradientDiscretization.h.

template<class X >

typedef Array<XGrad> MomentumPressureGradientDiscretization< X >::GradArray

Definition at line 43 of file MomentumPressureGradientDiscretization.h.

template<class X >

typedef GradientMatrix<X> MomentumPressureGradientDiscretization< X >::GradMatrix

Definition at line 35 of file MomentumPressureGradientDiscretization.h.

template<class X >

typedef NumTypeTraits<X>::T_Scalar MomentumPressureGradientDiscretization< X >::T_Scalar

Definition at line 30 of file MomentumPressureGradientDiscretization.h.

template<class X >

typedef Array<T_Scalar> MomentumPressureGradientDiscretization< X >::TArray

Definition at line 39 of file MomentumPressureGradientDiscretization.h.

template<class X >

typedef Vector<T_Scalar,3> MomentumPressureGradientDiscretization< X >::VectorT3

Definition at line 40 of file MomentumPressureGradientDiscretization.h.

template<class X >

typedef Array<VectorT3> MomentumPressureGradientDiscretization< X >::VectorT3Array

Definition at line 41 of file MomentumPressureGradientDiscretization.h.

template<class X >

typedef GradMatrix::Coord MomentumPressureGradientDiscretization< X >::VPCoeff

Definition at line 36 of file MomentumPressureGradientDiscretization.h.

template<class X >

typedef Array<X> MomentumPressureGradientDiscretization< X >::XArray

Definition at line 38 of file MomentumPressureGradientDiscretization.h.

template<class X >

typedef Gradient<X> MomentumPressureGradientDiscretization< X >::XGrad

Definition at line 34 of file MomentumPressureGradientDiscretization.h.

Constructor & Destructor Documentation

template<class X >

MomentumPressureGradientDiscretization< X >::MomentumPressureGradientDiscretization	(	const MeshList &	meshes,
		const GeomFields &	geomFields,
		FlowFields &	flowFields,
		GradientModel< X > &	pressureGradientModel
	)

inline

Definition at line 49 of file MomentumPressureGradientDiscretization.h.

                                                                                    :
     Discretization(meshes),
     _geomFields(geomFields),
     _flowFields(flowFields),
     _pressureGradientModel(pressureGradientModel)
   {}

Member Function Documentation

template<class X >

void MomentumPressureGradientDiscretization< X >::discretize	(	const Mesh &	mesh,
		MultiFieldMatrix &	mfmatrix,
		MultiField &	,
		MultiField &	rField
	)

inlinevirtual

Implements Discretization.

Definition at line 60 of file MomentumPressureGradientDiscretization.h.

References MomentumPressureGradientDiscretization< X >::_flowFields, MomentumPressureGradientDiscretization< X >::_geomFields, MomentumPressureGradientDiscretization< X >::_pressureGradientModel, GeomFields::area, GeomFields::areaMag, Mesh::getAllFaceCells(), Mesh::getBoundaryFaceGroups(), Mesh::getCells(), GradientMatrix< T_Scalar >::getCoeffs(), StorageSite::getCount(), Mesh::getFaceCells(), Mesh::getFaces(), MultiFieldMatrix::getMatrix(), CRConnectivity::getRow(), StorageSite::getSelfCount(), FaceGroup::groupType, MultiFieldMatrix::hasMatrix(), FlowFields::pressure, FlowFields::pressureGradient, reflectGradient(), FaceGroup::site, FlowFields::velocity, GeomFields::volume, and Array< T >::zero().

   {
     const StorageSite& cells = mesh.getCells();
 
     const TArray& cellVolume = dynamic_cast<const TArray&>(_geomFields.volume[cells]);
 
     const MultiField::ArrayIndex vIndex(&_flowFields.velocity,&cells);
     VectorT3Array& rCell = dynamic_cast<VectorT3Array&>(rField[vIndex]);
     GradArray& pGradCell = dynamic_cast<GradArray&>(_flowFields.pressureGradient[cells]);
     
     const int nCells = cells.getSelfCount();
 
     
     const StorageSite& faces = mesh.getFaces();
     const CRConnectivity& faceCells = mesh.getAllFaceCells();
     const VectorT3Array& faceArea =
       dynamic_cast<const VectorT3Array&>(_geomFields.area[faces]);
     const TArray& facePressure = dynamic_cast<const TArray&>(_flowFields.pressure[faces]);
 
     pGradCell.zero();
 
     const int nFaces = faces.getCount();
     for(int f=0; f<nFaces; f++)
     {
         const int c0 = faceCells(f,0);
         const int c1 = faceCells(f,1);
         pGradCell[c0].accumulate(faceArea[f],facePressure[f]);
         pGradCell[c1].accumulate(faceArea[f],-facePressure[f]);
     }
 
     for(int c=0; c<nCells; c++)
       pGradCell[c] /= cellVolume[c];
 
     // copy boundary values from adjacent cells
     foreach(const FaceGroupPtr fgPtr, mesh.getBoundaryFaceGroups())
     {
         const FaceGroup& fg = *fgPtr;
         const StorageSite& faces = fg.site;
         const CRConnectivity& faceCells = mesh.getFaceCells(faces);
         const int faceCount = faces.getCount();
 
         if (fg.groupType == "symmetry")
         {
             const VectorT3Array& faceArea =
               dynamic_cast<const VectorT3Array&>(_geomFields.area[faces]);
             const TArray& faceAreaMag =
               dynamic_cast<const TArray&>(_geomFields.areaMag[faces]);
             for(int f=0; f<faceCount; f++)
             {
                 const int c0 = faceCells(f,0);
                 const int c1 = faceCells(f,1);
                 const VectorT3 en = faceArea[f]/faceAreaMag[f];
                 reflectGradient(pGradCell[c1], pGradCell[c0], en);
             }
         }
         else
         {
             for(int f=0; f<faceCount; f++)
             {
                 const int c0 = faceCells(f,0);
                 const int c1 = faceCells(f,1);
                 
                 pGradCell[c1] = pGradCell[c0];
             }
         }
     }
   
 
     for(int c=0; c<nCells; c++)
     {
         rCell[c][0] -= cellVolume[c]*pGradCell[c][0];
         rCell[c][1] -= cellVolume[c]*pGradCell[c][1];
         rCell[c][2] -= cellVolume[c]*pGradCell[c][2];
         
     }
     
 
 #ifdef PV_COUPLED
     const MultiField::ArrayIndex pIndex(&_flowFields.pressure,&cells);
     if (mfmatrix.hasMatrix(vIndex,pIndex))
     {
         VPMatrix& vpMatrix =
           dynamic_cast<VPMatrix&>(mfmatrix.getMatrix(vIndex,pIndex));
 
         const GradientMatrix<X>& gradMatrix =
           _pressureGradientModel.getGradientMatrix(mesh, _geomFields);
 
         const Array<VPCoeff>& gradMatrixCoeffs = gradMatrix.getCoeffs();
         Array<VPCoeff>& vpDiag = vpMatrix.getDiag();
         Array<VPCoeff>& vpOffDiag = vpMatrix.getOffDiag();
  
         const CRConnectivity& conn = vpMatrix.getConnectivity();
         const Array<int>& row = conn.getRow();
         
         // all of this assumes that the connectivity of the gradient
         // matrix and vp matrix is the same
         for(int c=0; c<nCells; c++)
         {
             for(int nnb=row[c]; nnb<row[c+1]; nnb++)
             {
                 const VPCoeff& coeff = gradMatrixCoeffs[nnb];
                 vpDiag[c] += coeff*cellVolume[c];
                 vpOffDiag[nnb] -= coeff*cellVolume[c];
             }
         }                
     }
 #endif
   }