Public Types
typedef Domain< SC, LO, GO, NO >	Domain_Type

typedef Teuchos::RCP< Domain_Type >	DomainPtr_Type

typedef Teuchos::RCP< const Domain_Type >	DomainConstPtr_Type

typedef std::vector< DomainConstPtr_Type >	DomainConstPtr_vec_Type

typedef Teuchos::RCP< Mesh< SC, LO, GO, NO > >	MeshPtr_Type

typedef MeshUnstructured< SC, LO, GO, NO >	MeshUnstr_Type

typedef Teuchos::RCP< MeshUnstr_Type >	MeshUnstrPtr_Type

typedef Elements	Elements_Type

typedef Teuchos::RCP< Elements_Type >	ElementsPtr_Type

typedef Teuchos::RCP< const Elements_Type >	ElementsConstPtr_Type

typedef Matrix< SC, LO, GO, NO >	Matrix_Type

typedef Teuchos::RCP< Matrix_Type >	MatrixPtr_Type

typedef Matrix_Type::MapPtr_Type	MapPtr_Type

typedef Matrix_Type::MapConstPtr_Type	MapConstPtr_Type

typedef MultiVector< SC, LO, GO, NO >	MultiVector_Type

typedef Teuchos::RCP< MultiVector_Type >	MultiVectorPtr_Type

typedef Teuchos::RCP< const MultiVector_Type >	MultiVectorConstPtr_Type

typedef std::vector< GO >	vec_GO_Type

typedef std::vector< vec_GO_Type >	vec2D_GO_Type

typedef std::vector< vec2D_GO_Type >	vec3D_GO_Type

typedef Teuchos::RCP< vec3D_GO_Type >	vec3D_GO_ptr_Type

typedef boost::function< void(double x, double res, double t, const double *parameters)>	BC_func_Type

typedef AssembleFE< SC, LO, GO, NO >	AssembleFE_Type

typedef Teuchos::RCP< AssembleFE_Type >	AssembleFEPtr_Type

typedef AssembleFENavierStokes< SC, LO, GO, NO >	AssembleFENavierStokes_Type

typedef Teuchos::RCP< AssembleFENavierStokes_Type >	AssembleFENavierStokesPtr_Type

typedef AssembleFEGeneralizedNewtonian< SC, LO, GO, NO >	AssembleFEGeneralizedNewtonian_Type

typedef Teuchos::RCP< AssembleFEGeneralizedNewtonian_Type >	AssembleFEGeneralizedNewtonianPtr_Type

typedef AssembleFE_SCI_SMC_Active_Growth_Reorientation< SC, LO, GO, NO >	AssembleFE_SCI_SMC_Active_Growth_Reorientation_Type

typedef Teuchos::RCP< AssembleFE_SCI_SMC_Active_Growth_Reorientation_Type >	AssembleFE_SCI_SMC_Active_Growth_Reorientation_Ptr_Type

typedef std::vector< AssembleFEPtr_Type >	AssembleFEPtr_vec_Type

typedef BlockMatrix< SC, LO, GO, NO >	BlockMatrix_Type

typedef Teuchos::RCP< BlockMatrix_Type >	BlockMatrixPtr_Type

typedef BlockMultiVector< SC, LO, GO, NO >	BlockMultiVector_Type

typedef Teuchos::RCP< BlockMultiVector_Type >	BlockMultiVectorPtr_Type

typedef SmallMatrix< SC >	SmallMatrix_Type

typedef Teuchos::RCP< SmallMatrix_Type >	SmallMatrixPtr_Type

Public Member Functions
	FE (bool saveAssembly=false)

void	assemblyIdentity (MatrixPtr_Type &A)

void	assemblySurfaceIntegral (int dim, std::string FEType, MultiVectorPtr_Type a, std::string fieldType, RhsFunc_Type func, std::vector< SC > &funcParameter)

void	assemblySurfaceIntegralExternal (int dim, std::string FEType, MultiVectorPtr_Type f, MultiVectorPtr_Type d_rep, std::vector< SC > &funcParameter, RhsFunc_Type func, ParameterListPtr_Type params, int FEloc=0)

void	assemblyNonlinearSurfaceIntegralExternal (int dim, std::string FEType, MultiVectorPtr_Type f, MultiVectorPtr_Type d_rep, MatrixPtr_Type &Kext, std::vector< SC > &funcParameter, RhsFunc_Type func, ParameterListPtr_Type params, int FEloc=0)
	assemblyNonlinearSurfaceIntegralExternal -

void	assemblySurfaceIntegralFlag (int dim, std::string FEType, MultiVectorPtr_Type a, std::string fieldType, BC_func_Type func, std::vector< SC > &funcParameter)

void	assemblyAceGenTPM (MatrixPtr_Type &A00, MatrixPtr_Type &A01, MatrixPtr_Type &A10, MatrixPtr_Type &A11, MultiVectorPtr_Type &F0, MultiVectorPtr_Type &F1, MapPtr_Type &mapRepeated1, MapPtr_Type &mapRepeated2, ParameterListPtr_Type parameterList, MultiVectorPtr_Type u_repeatedNewton=Teuchos::null, MultiVectorPtr_Type p_repeatedNewton=Teuchos::null, MultiVectorPtr_Type u_repeatedTime=Teuchos::null, MultiVectorPtr_Type p_repeatedTime=Teuchos::null, bool update=true, bool updateHistory=true)

void	addFE (DomainConstPtr_Type domain)

void	doSetZeros (double eps=10 *Teuchos::ScalarTraits< SC >::eps())

void	assemblyEmptyMatrix (MatrixPtr_Type &A)

void	applyBTinv (vec3D_dbl_ptr_Type &dPhiIn, vec3D_dbl_Type &dPhiOut, SmallMatrix< SC > &Binv)

void	applyBTinv (vec3D_dbl_ptr_Type &dPhiIn, vec3D_dbl_Type &dPhiOut, const SmallMatrix< SC > &Binv)

void	assemblyLaplace (int Dimension, std::string FEType, int degree, MatrixPtr_Type &A, bool callFillComplete=true, int FELocExternal=-1)

void	assemblyMass (int dim, std::string FEType, std::string fieldType, MatrixPtr_Type &A, bool callFillComplete=true)

void	assemblyMass (int dim, std::string FEType, std::string fieldType, MatrixPtr_Type &A, int FEloc, bool callFillComplete=true)

void	assemblyLaplaceVecField (int dim, std::string FEType, int degree, MatrixPtr_Type &A, bool callFillComplete=true)

void	assemblyLaplaceVecFieldV2 (int dim, std::string FEType, int degree, MatrixPtr_Type &A, bool callFillComplete=true)

void	assemblyNonlinearLaplace (int dim, std::string FEType, int degree, MultiVectorPtr_Type u_rep, BlockMatrixPtr_Type &A, BlockMultiVectorPtr_Type &resVec, ParameterListPtr_Type params, std::string assembleMode, bool callFillComplete=true, int FELocExternal=-1)
	Assembly of Jacobian for nonlinear Laplace example.

void	assemblyLinElasXDimE (int dim, std::string FEType, MatrixPtr_Type &A, MultiVectorPtr_Type eModVec, double nu, bool callFillComplete=true)
	Same as assemblyLinElasXDim except for changing E Module Value.

void	determineEMod (std::string FEType, MultiVectorPtr_Type solution, MultiVectorPtr_Type &eModVec, DomainConstPtr_Type domain, ParameterListPtr_Type params)

void	assemblyLaplaceDiffusion (int Dimension, std::string FEType, int degree, MatrixPtr_Type &A, vec2D_dbl_Type diffusionTensor, bool callFillComplete=true, int FELocExternal=-1)

void	assemblyElasticityJacobianAndStressAceFEM (int dim, std::string FEType, MatrixPtr_Type &A, MultiVectorPtr_Type &f, MultiVectorPtr_Type u, ParameterListPtr_Type pList, double C, bool callFillComplete=true)

void	assemblyElasticityJacobianAceFEM (int dim, std::string FEType, MatrixPtr_Type &A, MultiVectorPtr_Type u, std::string material_model, double E, double nu, double C, bool callFillComplete=true)

void	assemblyElasticityStressesAceFEM (int dim, std::string FEType, MultiVectorPtr_Type &f, MultiVectorPtr_Type u, std::string material_model, double E, double nu, double C, bool callFillComplete=true)

void	assemblyAdvectionVecField (int dim, std::string FEType, MatrixPtr_Type &A, MultiVectorPtr_Type u, bool callFillComplete)
	Assembly of operator \int ((u_h \cdot \nabla ) v_h)v_h dx.

void	assemblyAdvectionInUVecField (int dim, std::string FEType, MatrixPtr_Type &A, MultiVectorPtr_Type u, bool callFillComplete)
	Assembly of operator \int ((v_h \cdot \nabla ) u_h)v_h dx.

void	assemblyDivAndDivT (int dim, std::string FEType1, std::string FEType2, int degree, MatrixPtr_Type &Bmat, MatrixPtr_Type &BTmat, MapConstPtr_Type map1, MapConstPtr_Type map2, bool callFillComplete=true)
	Assembly of \int q_h (nabla \cdot v_h) dx.

void	assemblyDivAndDivTFast (int dim, std::string FEType1, std::string FEType2, int degree, MatrixPtr_Type &Bmat, MatrixPtr_Type &BTmat, MapConstPtr_Type map1, MapConstPtr_Type map2, bool callFillComplete=true)
	Assembly of \int q_h (nabla \cdot v_h) dx.

void	assemblyBDStabilization (int dim, std::string FEType, MatrixPtr_Type &A, bool callFillComplete=true)

void	assemblyLaplaceXDim (int dim, std::string FEType, MatrixPtr_Type &A, CoeffFuncDbl_Type func, double *parameters, bool callFillComplete=true)

void	assemblyStress (int dim, std::string FEType, MatrixPtr_Type &A, CoeffFunc_Type func, int *parameters, bool callFillComplete=true)
	(\grad u + (\grad u)^T, \grad v ); symmetrischer Gradient, wenn func = 1.0

void	assemblyLinElasXDim (int dim, std::string FEType, MatrixPtr_Type &A, double lambda, double mu, bool callFillComplete=true)

void	assemblyAdditionalConvection (int dim, std::string FEType, MatrixPtr_Type &A, MultiVectorPtr_Type w, bool callFillComplete=true)
	Addional Matrix due to ALE derivation: \int \rho_f div(w) u_h \cdot v_f dx, with mesh velocity w.

void	assemblyFSICoupling (int dim, std::string FEType, MatrixPtr_Type &C, MatrixPtr_Type &C_T, int FEloc1, int FEloc2, MapConstPtr_Type map1, MapConstPtr_Type map2, bool callFillComplete=true)

void	assemblyDummyCoupling (int dim, std::string FEType, MatrixPtr_Type &C, int FEloc, bool callFillComplete)

void	assemblyGeometryCoupling (int dim, std::string FEType, MatrixPtr_Type &C, int FEloc, MapConstPtr_Type map1, MapConstPtr_Type map2, MapConstPtr_Type map3, bool callFillComplete=true)

void	assemblyShapeDerivativeVelocity (int dim, std::string FEType1, std::string FEType2, MatrixPtr_Type &D, int FEloc, MultiVectorPtr_Type u, MultiVectorPtr_Type w, MultiVectorPtr_Type p, double dt, double rho, double nu, bool callFillComplete=true)

void	assemblyShapeDerivativeDivergence (int dim, std::string FEType1, std::string FEType2, MatrixPtr_Type &DB, int FEloc1, int FEloc2, MapConstPtr_Type map1_unique, MapConstPtr_Type map2_unique, MultiVectorPtr_Type u, bool callFillComplete=true)

void	assemblyPressureMeanValue (int dim, std::string FEType, MatrixPtr_Type a, MatrixPtr_Type aT)
	Assembling Pressure Integral to determine pressure mean value.

void	assemblyRHS (int dim, std::string FEType, MultiVectorPtr_Type a, std::string fieldType, RhsFunc_Type func, std::vector< SC > &funcParameter)

void	assemblyRHSDegTest (int dim, std::string FEType, MultiVectorPtr_Type a, std::string fieldType, RhsFunc_Type func, std::vector< SC > &funcParameter, int degree)

void	buildFullDPhi (vec3D_dbl_ptr_Type dPhi, Teuchos::Array< SmallMatrix< double > > &dPhiMat)

void	fillMatrixArray (SmallMatrix< double > &matIn, double *matArrayOut, std::string order, int offset=0)

void	epsilonTensor (vec_dbl_Type &basisValues, SmallMatrix< SC > &epsilonValues, int activeDof)

void	assemblyNavierStokes (int dim, std::string FETypeVelocity, std::string FETypePressure, int degree, int dofsVelocity, int dofsPressure, MultiVectorPtr_Type u_rep, MultiVectorPtr_Type p_rep, BlockMatrixPtr_Type &A, BlockMultiVectorPtr_Type &resVec, SmallMatrix_Type coeff, ParameterListPtr_Type params, bool reAssemble, std::string assembleMode, bool callFillComplete=true, int FELocExternal=-1)
	Assembly of Jacobian for NavierStokes.

void	assemblyLaplaceAssFE (int dim, std::string FEType, int degree, int dofs, BlockMatrixPtr_Type &A, bool callFillComplete, int FELocExternal=-1)
	Assembly of constant stiffness matix for laplacian operator $\Delta$ .

void	assemblyAceDeformDiffu (int dim, std::string FETypeChem, std::string FETypeSolid, int degree, int dofsChem, int dofsSolid, MultiVectorPtr_Type c_rep, MultiVectorPtr_Type d_rep, BlockMatrixPtr_Type &A, BlockMultiVectorPtr_Type &resVec, ParameterListPtr_Type params, std::string assembleMode, bool callFillComplete=true, int FELocExternal=-1)

void	assemblyAceDeformDiffuBlock (int dim, std::string FETypeChem, std::string FETypeSolid, int degree, int dofsChem, int dofsSolid, MultiVectorPtr_Type c_rep, MultiVectorPtr_Type d_rep, BlockMatrixPtr_Type &A, int blockRow, int blockCol, BlockMultiVectorPtr_Type &resVec, int block, ParameterListPtr_Type params, std::string assembleMode, bool callFillComplete=true, int FELocExternal=-1)

void	advanceInTimeAssemblyFEElements (double dt, MultiVectorPtr_Type d_rep, MultiVectorPtr_Type c_rep)

void	assemblyLinearElasticity (int dim, std::string FEType, int degree, int dofs, MultiVectorPtr_Type d_rep, BlockMatrixPtr_Type &A, BlockMultiVectorPtr_Type &resVec, ParameterListPtr_Type params, bool reAssemble, std::string assembleMode, bool callFillComplete=true, int FELocExternal=-1)
	Assembly of Jacobian.

void	assemblyNonLinearElasticity (int dim, std::string FEType, int degree, int dofs, MultiVectorPtr_Type d_rep, BlockMatrixPtr_Type &A, BlockMultiVectorPtr_Type &resVec, ParameterListPtr_Type params, bool callFillComplete=true, int FELocExternal=-1)
	Assembly of Jacobian for nonlinear Elasticity.

void	assemblyNonLinearElasticity (int dim, std::string FEType, int degree, int dofs, MultiVectorPtr_Type d_rep, BlockMatrixPtr_Type &A, BlockMultiVectorPtr_Type &resVec, ParameterListPtr_Type params, DomainConstPtr_Type domain, MultiVectorPtr_Type eModVec, bool callFillComplete=true, int FELocExternal=-1)
	Assembly of Jacobian for nonlinear Elasticity.

void	checkMeshOrientation (int dim, std::string FEType)

void	computeSteadyViscosityFE_CM (int dim, std::string FETypeVelocity, std::string FETypePressure, int dofsVelocity, int dofsPressure, MultiVectorPtr_Type u_rep, MultiVectorPtr_Type p_rep, ParameterListPtr_Type params)
	Postprocessing: Using a converged velocity solution -> compute averaged viscosity inside an element at center of mass.

Public Attributes
DomainConstPtr_vec_Type	domainVec_

Teuchos::RCP< ElementSpec >	es_

BlockMultiVectorPtr_Type	const_output_fields

Member Function Documentation

◆ assemblyAceDeformDiffu()

template<class SC, class LO, class GO, class NO>

void FEDD::FE< SC, LO, GO, NO >::assemblyAceDeformDiffu	(	int	dim,
		std::string	FETypeChem,
		std::string	FETypeSolid,
		int	degree,
		int	dofsChem,
		int	dofsSolid,
		MultiVectorPtr_Type	c_rep,
		MultiVectorPtr_Type	d_rep,
		BlockMatrixPtr_Type &	A,
		BlockMultiVectorPtr_Type &	resVec,
		ParameterListPtr_Type	params,
		std::string	assembleMode,
		bool	callFillComplete = true,
		int	FELocExternal = -1 )

Tupel construction follows follwing pattern: std::string: Physical Entity (i.e. Velocity) , std::string: Discretisation (i.e. "P2"), int: Degrees of Freedom per Node, int: Number of Nodes per element)

Here is the call graph for this function:

Here is the caller graph for this function:

◆ assemblyAceDeformDiffuBlock()

template<class SC, class LO, class GO, class NO>

void FEDD::FE< SC, LO, GO, NO >::assemblyAceDeformDiffuBlock	(	int	dim,
		std::string	FETypeChem,
		std::string	FETypeSolid,
		int	degree,
		int	dofsChem,
		int	dofsSolid,
		MultiVectorPtr_Type	c_rep,
		MultiVectorPtr_Type	d_rep,
		BlockMatrixPtr_Type &	A,
		int	blockRow,
		int	blockCol,
		BlockMultiVectorPtr_Type &	resVec,
		int	block,
		ParameterListPtr_Type	params,
		std::string	assembleMode,
		bool	callFillComplete = true,
		int	FELocExternal = -1 )

Tupel construction follows follwing pattern: std::string: Physical Entity (i.e. Velocity) , std::string: Discretisation (i.e. "P2"), int: Degrees of Freedom per Node, int: Number of Nodes per element)

Here is the call graph for this function:

Here is the caller graph for this function:

◆ assemblyAdditionalConvection()

template<class SC, class LO, class GO, class NO>

void FEDD::FE< SC, LO, GO, NO >::assemblyAdditionalConvection	(	int	dim,
		std::string	FEType,
		MatrixPtr_Type &	A,
		MultiVectorPtr_Type	w,
		bool	callFillComplete = true )

Addional Matrix due to ALE derivation: \int \rho_f div(w) u_h \cdot v_f dx, with mesh velocity w.

Dieser Term entsteht durch schwache Formulierung der ALE-Zeitableitung und bleibt in nicht-conservativer Form vorhanden. In conservativer Form "verschwindet" der Term in die conservative Form der Konvektion. Das betrachten wir aber nicht. Der Term lautet: (\grad \cdot w) u \cdot v und wir bei der endgueltigen Assemblierung subtrahiert. Also -(\grad \cdot w) u \cdot v

Here is the call graph for this function:

Here is the caller graph for this function:

◆ assemblyBDStabilization()

template<class SC, class LO, class GO, class NO>

void FEDD::FE< SC, LO, GO, NO >::assemblyBDStabilization	(	int	dim,
		std::string	FEType,
		MatrixPtr_Type &	A,
		bool	callFillComplete = true )

Bochev-Dohrmann stabilization for P1-P1 finite elements. Must be scaled with 1/nu for general Navier-Stokes problem.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ assemblyLaplaceAssFE()

template<class SC, class LO, class GO, class NO>

void FEDD::FE< SC, LO, GO, NO >::assemblyLaplaceAssFE	(	int	dim,
		std::string	FEType,
		int	degree,
		int	dofs,
		BlockMatrixPtr_Type &	A,
		bool	callFillComplete,
		int	FELocExternal = -1 )

Assembly of constant stiffness matix for laplacian operator $\Delta$ .

Parameters

[in]	dim	Dimension
[in]	FEType	FE Discretization
[in]	degree	Degree of basis function
[in]	A	Resulting matrix
[in]	callFillComplete	If Matrix A should be completely filled at end of function
[in]	FELocExternal

Here is the call graph for this function:

Here is the caller graph for this function:

◆ assemblyLaplaceXDim()

template<class SC, class LO, class GO, class NO>

void FEDD::FE< SC, LO, GO, NO >::assemblyLaplaceXDim	(	int	dim,
		std::string	FEType,
		MatrixPtr_Type &	A,
		CoeffFuncDbl_Type	func,
		double *	parameters,
		bool	callFillComplete = true )

Fuer diskret harmonische Fortsetzung mit heuristischer Skalierung mit Hilfe von DistancesToInterface_ Aehnelt also nicht direkt dem AssemblyLaplace (mit CoeffFunc) von oben

Here is the call graph for this function:

Here is the caller graph for this function:

◆ assemblyLinearElasticity()

template<class SC, class LO, class GO, class NO>

void FEDD::FE< SC, LO, GO, NO >::assemblyLinearElasticity	(	int	dim,
		std::string	FEType,
		int	degree,
		int	dofs,
		MultiVectorPtr_Type	d_rep,
		BlockMatrixPtr_Type &	A,
		BlockMultiVectorPtr_Type &	resVec,
		ParameterListPtr_Type	params,
		bool	reAssemble,
		std::string	assembleMode,
		bool	callFillComplete = true,
		int	FELocExternal = -1 )

Assembly of Jacobian.

Parameters

[in]	dim	Dimension
[in]	FEType	FE Discretization
[in]	degree	Degree of basis function
[in]	A	Resulting matrix
[in]	callFillComplete	If Matrix A should be completely filled at end of function
[in]	FELocExternal

Inserting element stiffness matrices into global stiffness matrix

Parameters

[in]	&A	Global Block Matrix
[in]	elementMatrix	Stiffness matrix of one element
[in]	element	Corresponding finite element
[in]	map	Map that corresponds to repeated nodes of first block
[in]	map	Map that corresponds to repeated nodes of second block

Inserting local rhsVec into global residual Mv;

Parameters

[in]	res	BlockMultiVector of residual vec; Repeated distribution; 2 blocks
[in]	rhsVec	sorted the same way as residual vec
[in]	element	of block1

Assembly of Jacobian for Linear Elasticity

Parameters

[in]	dim	Dimension
[in]	FEType	FE Discretization
[in]	degree	Degree of basis function
[in]	A	Resulting matrix
[in]	callFillComplete	If Matrix A should be completely filled at end of function
[in]	FELocExternal

Tupel construction follows follwing pattern: std::string: Physical Entity (i.e. Velocity) , std::string: Discretisation (i.e. "P2"), int: Degrees of Freedom per Node, int: Number of Nodes per element)

Here is the call graph for this function:

Here is the caller graph for this function:

◆ assemblyLinElasXDim()

template<class SC, class LO, class GO, class NO>

void FEDD::FE< SC, LO, GO, NO >::assemblyLinElasXDim	(	int	dim,
		std::string	FEType,
		MatrixPtr_Type &	A,
		double	lambda,
		double	mu,
		bool	callFillComplete = true )

2*\mu*(\eps(u):\eps(v)) + \lambda*tr(\eps(u))*tr(\eps(v)), wobei tr(\eps(u)) = div(u)

Here is the call graph for this function:

Here is the caller graph for this function:

◆ assemblyLinElasXDimE()

template<class SC, class LO, class GO, class NO>

void FEDD::FE< SC, LO, GO, NO >::assemblyLinElasXDimE	(	int	dim,
		std::string	FEType,
		MatrixPtr_Type &	A,
		MultiVectorPtr_Type	eModVec,
		double	nu,
		bool	callFillComplete = true )

Same as assemblyLinElasXDim except for changing E Module Value.

\lambda = E(T)* \nu / ( (1+\nu))*(1-2*nu))

Here is the call graph for this function:

Here is the caller graph for this function:

◆ assemblyNavierStokes()

template<class SC, class LO, class GO, class NO>

void FEDD::FE< SC, LO, GO, NO >::assemblyNavierStokes	(	int	dim,
		std::string	FETypeVelocity,
		std::string	FETypePressure,
		int	degree,
		int	dofsVelocity,
		int	dofsPressure,
		MultiVectorPtr_Type	u_rep,
		MultiVectorPtr_Type	p_rep,
		BlockMatrixPtr_Type &	A,
		BlockMultiVectorPtr_Type &	resVec,
		SmallMatrix_Type	coeff,
		ParameterListPtr_Type	params,
		bool	reAssemble,
		std::string	assembleMode,
		bool	callFillComplete = true,
		int	FELocExternal = -1 )

Assembly of Jacobian for NavierStokes.

Parameters

[in]	dim	Dimension
[in]	FEType	FE Discretization
[in]	degree	Degree of basis function
[in]	A	Resulting matrix
[in]	callFillComplete	If Matrix A should be completely filled at end of function
[in]	FELocExternal

Tupel construction follows follwing pattern: std::string: Physical Entity (i.e. Velocity) , std::string: Discretisation (i.e. "P2"), int: Degrees of Freedom per Node, int: Number of Nodes per element)

Here is the call graph for this function:

Here is the caller graph for this function:

◆ assemblyNonLinearElasticity() [1/2]

template<class SC, class LO, class GO, class NO>

void FEDD::FE< SC, LO, GO, NO >::assemblyNonLinearElasticity	(	int	dim,
		std::string	FEType,
		int	degree,
		int	dofs,
		MultiVectorPtr_Type	d_rep,
		BlockMatrixPtr_Type &	A,
		BlockMultiVectorPtr_Type &	resVec,
		ParameterListPtr_Type	params,
		bool	callFillComplete = true,
		int	FELocExternal = -1 )

Assembly of Jacobian for nonlinear Elasticity.

Parameters

[in]	dim	Dimension
[in]	FEType	FE Discretization
[in]	degree	Degree of basis function
[in]	A	Resulting matrix
[in]	callFillComplete	If Matrix A should be completely filled at end of function
[in]	FELocExternal

Tupel construction follows follwing pattern: std::string: Physical Entity (i.e. Velocity) , std::string: Discretisation (i.e. "P2"), int: Degrees of Freedom per Node, int: Number of Nodes per element)

Here is the call graph for this function:

Here is the caller graph for this function:

◆ assemblyNonLinearElasticity() [2/2]

template<class SC, class LO, class GO, class NO>

void FEDD::FE< SC, LO, GO, NO >::assemblyNonLinearElasticity	(	int	dim,
		std::string	FEType,
		int	degree,
		int	dofs,
		MultiVectorPtr_Type	d_rep,
		BlockMatrixPtr_Type &	A,
		BlockMultiVectorPtr_Type &	resVec,
		ParameterListPtr_Type	params,
		DomainConstPtr_Type	domain,
		MultiVectorPtr_Type	eModVec,
		bool	callFillComplete = true,
		int	FELocExternal = -1 )

Assembly of Jacobian for nonlinear Elasticity.

Parameters

[in]	dim	Dimension
[in]	FEType	FE Discretization
[in]	degree	Degree of basis function
[in]	A	Resulting matrix
[in]	callFillComplete	If Matrix A should be completely filled at end of function
[in]	FELocExternal

Tupel construction follows follwing pattern: std::string: Physical Entity (i.e. Velocity) , std::string: Discretisation (i.e. "P2"), int: Degrees of Freedom per Node, int: Number of Nodes per element)

Here is the call graph for this function:

◆ assemblyNonlinearLaplace()

template<class SC, class LO, class GO, class NO>

void FEDD::FE< SC, LO, GO, NO >::assemblyNonlinearLaplace	(	int	dim,
		std::string	FEType,
		int	degree,
		MultiVectorPtr_Type	u_rep,
		BlockMatrixPtr_Type &	A,
		BlockMultiVectorPtr_Type &	resVec,
		ParameterListPtr_Type	params,
		std::string	assembleMode,
		bool	callFillComplete = true,
		int	FELocExternal = -1 )

Assembly of Jacobian for nonlinear Laplace example.

Parameters

[in]	dim	Dimension
[in]	FEType	FE Discretization
[in]	degree	Degree of basis function
[in]	u_rep	The current solution
[in]	A	Resulting matrix
[in]	resVec	Resulting residual
[in]	params	Params needed by the problem. Placeholder for now.
[in]	assembleMode	What should be assembled i.e. Rhs (residual) or the Jacobian
[in]	callFillComplete	If Matrix A should be redistributed across MPI procs at end of function
[in]	FELocExternal	?

Here is the call graph for this function:

Here is the caller graph for this function:

◆ assemblyNonlinearSurfaceIntegralExternal()

template<class SC, class LO, class GO, class NO>

void FEDD::FE< SC, LO, GO, NO >::assemblyNonlinearSurfaceIntegralExternal	(	int	dim,
		std::string	FEType,
		MultiVectorPtr_Type	f,
		MultiVectorPtr_Type	d_rep,
		MatrixPtr_Type &	Kext,
		std::vector< SC > &	funcParameter,
		RhsFunc_Type	func,
		ParameterListPtr_Type	params,
		int	FEloc = 0 )

assemblyNonlinearSurfaceIntegralExternal -

This force is assembled in AceGEN as deformation-dependent load. This force is applied as Pressure boundary in opposite direction of surface normal.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ assemblyPressureMeanValue()

template<class SC, class LO, class GO, class NO>

void FEDD::FE< SC, LO, GO, NO >::assemblyPressureMeanValue	(	int	dim,
		std::string	FEType,
		MatrixPtr_Type	a,
		MatrixPtr_Type	aT )

Assembling Pressure Integral to determine pressure mean value.

Assembling \int p \dx = 0. Thus, we need the integral part for the mean pressure value. We need this to be in matrix format, as it is added to the system.

Parameters

dim	Dimension
FEType	FEType
a	Resultin matrix with one column
dim	Dimension
FEType	FEType
a	Matrix Ptr with resulting assembly

Here is the call graph for this function:

Here is the caller graph for this function:

◆ computeSteadyViscosityFE_CM()

template<class SC, class LO, class GO, class NO>

void FEDD::FE< SC, LO, GO, NO >::computeSteadyViscosityFE_CM	(	int	dim,
		std::string	FETypeVelocity,
		std::string	FETypePressure,
		int	dofsVelocity,
		int	dofsPressure,
		MultiVectorPtr_Type	u_rep,
		MultiVectorPtr_Type	p_rep,
		ParameterListPtr_Type	params )

Postprocessing: Using a converged velocity solution -> compute averaged viscosity inside an element at center of mass.

Parameters

[in]	dim	Dimension
[in]	FEType	FE Discretization
[in]	degree	Degree of basis function
[in]	repeated	solution fields for u and p
[in]	parameter	lists

Here is the call graph for this function:

Here is the caller graph for this function:

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

feddlib/core/FE/FE_decl.hpp
feddlib/core/FE/FE_def.hpp

Public Types

Public Member Functions

Public Attributes

Member Function Documentation

◆ assemblyAceDeformDiffu()

◆ assemblyAceDeformDiffuBlock()

◆ assemblyAdditionalConvection()

◆ assemblyBDStabilization()

◆ assemblyLaplaceAssFE()

◆ assemblyLaplaceXDim()

◆ assemblyLinearElasticity()

◆ assemblyLinElasXDim()

◆ assemblyLinElasXDimE()

◆ assemblyNavierStokes()

◆ assemblyNonLinearElasticity() [1/2]

◆ assemblyNonLinearElasticity() [2/2]

◆ assemblyNonlinearLaplace()

◆ assemblyNonlinearSurfaceIntegralExternal()

◆ assemblyPressureMeanValue()

◆ computeSteadyViscosityFE_CM()