Class with methods to manage fields defined on the domain boundary. More...

#include <PostProcessingBoundary.hpp>

Collaboration diagram for PostProcessingBoundary< MeshType >:

Public Types
typedef MeshType::elementShape_Type	elementGeometricShape_Type

typedef elementGeometricShape_Type::GeoBShape	facetGeometricShape_Type

typedef MeshType	mesh_Type

typedef std::shared_ptr< MeshType >	meshPtr_Type

typedef CurrentFEManifold *	currentBdFEPtr_Type

typedef DOF *	dofPtr_Type

Constructors & Destructor
	PostProcessingBoundary ()
	Empty Constructor. More...

	PostProcessingBoundary (const PostProcessingBoundary &)
	Copy constructor. More...

	PostProcessingBoundary (meshPtr_Type mesh, std::vector< currentBdFEPtr_Type > currentBdFEVector, std::vector< dofPtr_Type > dofVector, const MapEpetra &epetraMap, UInt nFESpaces=1)
	Constructor. More...

	PostProcessingBoundary (meshPtr_Type mesh, currentBdFEPtr_Type currentBdFE, dofPtr_Type dof, const MapEpetra &epetraMap)
	Constructor for the case in which we have only one currentBdFE and dof. More...

	PostProcessingBoundary (meshPtr_Type mesh, currentBdFEPtr_Type feBdu, dofPtr_Type dofu, currentBdFEPtr_Type feBdp, dofPtr_Type dofp, const MapEpetra &epetraMap)
	Constructor for the case in which we have two currentBdFE's and dof's. More...

Methods
Real	measure (const markerID_Type &flag)

template<typename VectorType >
Real	flux (const VectorType &vectorField, const markerID_Type &flag, UInt feSpace=0, UInt nDim=nDimensions)

template<typename VectorType >
Real	kineticNormalStress (const VectorType &velocity, const Real &density, const markerID_Type &flag, UInt feSpace=0, UInt nDim=nDimensions)

template<typename VectorType >
Real	kineticNormalStressDerivative (const VectorType &velocity, const VectorType &velocityDerivative, const Real &density, const markerID_Type &flag, UInt feSpace=0, UInt nDim=nDimensions)

template<typename VectorType >
Vector	average (const VectorType &field, const markerID_Type &flag, UInt feSpace=0, UInt nDim=1)

Vector	normal (const markerID_Type &flag, UInt feSpace=0, UInt nDim=nDimensions)

Vector	geometricCenter (const markerID_Type &flag, UInt feSpace=0, UInt nDim=nDimensions)

void	showDOFIndexMap (std::ostream &output=std::cout) const

void	showPatchesMeasure (std::ostream &output=std::cout) const

void	showPatchesNormal (std::ostream &output=std::cout) const

void	showPatchesPhi (std::ostream &output=std::cout) const

const Vector &	patchMeasureInFESpace (const UInt &feSpace=0) const

const Vector &	patchNormalInFESpace (const UInt &feSpace=0) const

const std::vector< ID > &	dofGlobalIdInFESpace (const UInt &feSpace=0) const

const UInt &	numBoundaryDofInFESpace (const UInt &feSpace=0) const
	Number of boundary DOF for the mesh at hand. More...

Private Methods
UInt	M_numFESpaces

std::vector< UInt >	M_numBoundaryDofVector

std::vector< UInt >	M_numDofPerPeakVector

std::vector< UInt >	M_numDofPerRidgeVector

std::vector< UInt >	M_numDofPerFacetVector

UInt	M_numRidgesPerFacet

UInt	M_numFacetPerFacet

UInt	M_numPeaksPerElement

UInt	M_numRidgesPerElement

std::vector< UInt >	M_numPeakDofPerFacetVector

std::vector< UInt >	M_numRidgeDofPerFacetVector

std::vector< UInt >	M_numTotalDofPerFacetVector

std::vector< UInt >	M_numPeakDofPerElement

std::vector< UInt >	M_numRidgeDofPerElementVector

UInt	M_numBoundaryFacets

std::vector< UInt >	M_numTotalDofVector

std::vector< Vector >	M_patchMeasureVector

std::vector< Vector >	M_patchNormalVector

std::vector< Vector >	M_patchIntegratedPhiVector

std::map< markerID_Type, std::list< ID > >	M_boundaryMarkerToFacetIdMap

std::vector< std::vector< std::vector< ID > > >	M_vectorNumberingPerFacetVector

std::vector< std::vector< ID > >	M_dofGlobalIdVector

std::vector< currentBdFEPtr_Type >	M_currentBdFEPtrVector

std::vector< dofPtr_Type >	M_dofPtrVector

meshPtr_Type	M_meshPtr

std::shared_ptr< MapEpetra >	M_epetraMapPtr

const Int	M_geoDimension

void	computePatchesMeasure ()

void	computePatchesNormal ()

void	computePatchesPhi ()

void	buildVectors ()

Detailed Description

template<typename MeshType>
class LifeV::PostProcessingBoundary< MeshType >

Class with methods to manage fields defined on the domain boundary.

The data structures are based on vector M_vectorNumberingPerFacetVector:

the size is equal to the number of boundary facets in the mesh
each component is a vector of identifiers
in each vector of identifiers, the i-th component is the position in vector M_dofGlobalIdVector where to find the global Id for i-th dof in the facet

Vector M_dofGlobalIdVector has this usage:

the size is equal to the total number of boundary dof's
the k-th component is the global numbering of the k-th boundary dof

How to use M_vectorNumberingPerFacetVector and M_dofGlobalIdVector together?

M_vectorNumberingPerFacetVector[ j ] is a vector containing the vector indices for boundary face j
M_dofGlobalIdVector[ M_vectorNumberingPerFacetVector[ j ][ i ] ] is the global ID associated to the i-th dof on j-th face

NB: here "global" is intended wrt the global mesh (prior to partitioning, if this applies)

Definition at line 78 of file PostProcessingBoundary.hpp.

Member Typedef Documentation

◆ elementGeometricShape_Type

typedef MeshType::elementShape_Type elementGeometricShape_Type

private

Definition at line 83 of file PostProcessingBoundary.hpp.

◆ facetGeometricShape_Type

typedef elementGeometricShape_Type::GeoBShape facetGeometricShape_Type

private

Definition at line 84 of file PostProcessingBoundary.hpp.

◆ mesh_Type

typedef MeshType mesh_Type

private

Definition at line 85 of file PostProcessingBoundary.hpp.

◆ meshPtr_Type

typedef std::shared_ptr<MeshType> meshPtr_Type

private

Definition at line 86 of file PostProcessingBoundary.hpp.

◆ currentBdFEPtr_Type

typedef CurrentFEManifold* currentBdFEPtr_Type

private

Definition at line 87 of file PostProcessingBoundary.hpp.

◆ dofPtr_Type

typedef DOF* dofPtr_Type

private

Definition at line 88 of file PostProcessingBoundary.hpp.

Constructor & Destructor Documentation

◆ PostProcessingBoundary() [1/5]

PostProcessingBoundary ( )

inline

Empty Constructor.

Definition at line 97 of file PostProcessingBoundary.hpp.

◆ PostProcessingBoundary() [2/5]

PostProcessingBoundary ( const PostProcessingBoundary< MeshType > & )

inline

Copy constructor.

Note: all pointer members are copied (no new allocation is done in the class)

Definition at line 104 of file PostProcessingBoundary.hpp.

◆ PostProcessingBoundary() [3/5]

PostProcessingBoundary	(	meshPtr_Type	mesh,
		std::vector< currentBdFEPtr_Type >	currentBdFEVector,
		std::vector< dofPtr_Type >	dofVector,
		const MapEpetra &	epetraMap,
		UInt	nFESpaces = `1`
	)

Constructor.

In this general case we allow to pass an arbitrary number (nFESpaces) of dof/fe classes

NOTE: in most parts of the code, only currentBdFEVector[0] and dofVector[0] will be considered

Parameters

mesh	the mesh
currentBdFEVector	a vector of finite element prototypes for boundary elements
dofVector	a vector of classes for the description of degrees of freedom
epetraMap	the map describing the partition over different processors
nFESpaces	number of elements in vectors currentBdFEVector, dofVector

Definition at line 389 of file PostProcessingBoundary.hpp.

◆ PostProcessingBoundary() [4/5]

PostProcessingBoundary	(	meshPtr_Type	mesh,
		currentBdFEPtr_Type	currentBdFE,
		dofPtr_Type	dof,
		const MapEpetra &	epetraMap
	)

Constructor for the case in which we have only one currentBdFE and dof.

Definition at line 430 of file PostProcessingBoundary.hpp.

◆ PostProcessingBoundary() [5/5]

PostProcessingBoundary	(	meshPtr_Type	mesh,
		currentBdFEPtr_Type	feBdu,
		dofPtr_Type	dofu,
		currentBdFEPtr_Type	feBdp,
		dofPtr_Type	dofp,
		const MapEpetra &	epetraMap
	)

Constructor for the case in which we have two currentBdFE's and dof's.

This is the case of NS problem, in which we will want to consider both velocity and pressure dof/fe classes

Definition at line 467 of file PostProcessingBoundary.hpp.

Member Function Documentation

◆ computePatchesMeasure()

void computePatchesMeasure ( )

private

These methods build the data structures describing patches of boundary elements (patch measure, patch normal and integral of the test function over the patch)

Definition at line 1137 of file PostProcessingBoundary.hpp.