Assembly Class Reference

Keeps track of stuff related to assembling. More...

#include <Assembly.h>

Classes
class	FEShapeData
class	VectorFEShapeData

Public Member Functions
	Assembly (SystemBase &sys, THREAD_ID tid)
virtual	~Assembly ()
void	buildFE (FEType type)
	Build FEs with a type. More...
void	buildFaceFE (FEType type)
	Build FEs for a face with a type. More...
void	buildNeighborFE (FEType type)
	Build FEs for a neighbor with a type. More...
void	buildFaceNeighborFE (FEType type)
	Build FEs for a neighbor face with a type. More...
void	buildVectorFE (FEType type)
	Build Vector FEs with a type. More...
void	buildVectorFaceFE (FEType type)
	Build Vector FEs for a face with a type. More...
void	buildVectorNeighborFE (FEType type)
	Build Vector FEs for a neighbor with a type. More...
void	buildVectorFaceNeighborFE (FEType type)
	Build Vector FEs for a neighbor face with a type. More...
FEBase *&	getFE (FEType type, unsigned int dim)
	Get a reference to a pointer that will contain the current volume FE. More...
FEBase *&	getFENeighbor (FEType type, unsigned int dim)
	Get a reference to a pointer that will contain the current 'neighbor' FE. More...
FEBase *&	getFEFace (FEType type, unsigned int dim)
	Get a reference to a pointer that will contain the current "face" FE. More...
FEBase *&	getFEFaceNeighbor (FEType type, unsigned int dim)
	Get a reference to a pointer that will contain the current "neighbor" FE. More...
FEVectorBase *&	getVectorFE (FEType type, unsigned int dim)
	Get a reference to a pointer that will contain the current volume FEVector. More...
FEVectorBase *&	getVectorFENeighbor (FEType type, unsigned int dim)
	GetVector a reference to a pointer that will contain the current 'neighbor' FE. More...
FEVectorBase *&	getVectorFEFace (FEType type, unsigned int dim)
	GetVector a reference to a pointer that will contain the current "face" FE. More...
FEVectorBase *&	getVectorFEFaceNeighbor (FEType type, unsigned int dim)
	GetVector a reference to a pointer that will contain the current "neighbor" FE. More...
QBase *&	qRule ()
	Returns the reference to the current quadrature being used. More...
const MooseArray< Point > &	qPoints ()
	Returns the reference to the quadrature points. More...
const MooseArray< Point > &	physicalPoints ()
	The current points in physical space where we have reinited through reinitAtPhysical() More...
const MooseArray< Real > &	JxW ()
	Returns the reference to the transformed jacobian weights. More...
template<ComputeStage compute_stage>
const MooseArray< ADReal > &	adJxW () const
template<ComputeStage compute_stage>
const MooseArray< ADReal > &	adJxWFace () const
template<ComputeStage compute_stage>
const MooseArray< ADReal > &	adCurvatures () const
const MooseArray< Real > &	coordTransformation () const
	Returns the reference to the coordinate transformation coefficients. More...
template<ComputeStage compute_stage>
const MooseArray< ADReal > &	adCoordTransformation () const
	Returns the reference to the AD version of the coordinate transformation coefficients. More...
const Moose::CoordinateSystemType &	coordSystem ()
	Get the coordinate system type. More...
QBase *&	qRuleFace ()
	Returns the reference to the current quadrature being used on a current face. More...
const MooseArray< Point > &	qPointsFace ()
	Returns the reference to the current quadrature being used. More...
const MooseArray< Real > &	JxWFace ()
	Returns the reference to the transformed jacobian weights on a current face. More...
const MooseArray< Point > &	normals ()
	Returns the array of normals for quadrature points on a current side. More...
template<ComputeStage compute_stage>
const ADPoint &	adNormals () const
template<ComputeStage compute_stage>
const ADPoint &	adQPoints () const
template<ComputeStage compute_stage>
const ADPoint &	adQPointsFace () const
const Elem *&	elem ()
	Return the current element. More...
const SubdomainID &	currentSubdomainID () const
	Return the current subdomain ID. More...
void	setCurrentSubdomainID (SubdomainID i)
	set the current subdomain ID More...
const Real &	elemVolume ()
	Returns the reference to the current element volume. More...
unsigned int &	side ()
	Returns the current side. More...
unsigned int &	neighborSide ()
	Returns the current neighboring side. More...
const Elem *&	sideElem ()
	Returns the side element. More...
const Real &	sideElemVolume ()
	Returns the reference to the volume of current side element. More...
const Elem *&	neighbor ()
	Return the neighbor element. More...
const SubdomainID &	currentNeighborSubdomainID () const
	Return the current subdomain ID. More...
void	setCurrentNeighborSubdomainID (SubdomainID i)
	set the current subdomain ID More...
const Real &	neighborVolume ()
	Returns the reference to the current neighbor volume. More...
QBase *&	qRuleNeighbor ()
	Returns the reference to the current quadrature being used on a current neighbor. More...
const MooseArray< Real > &	JxWNeighbor ()
	Returns the reference to the transformed jacobian weights on a current face. More...
const Node *&	node ()
	Returns the reference to the node. More...
const Node *&	nodeNeighbor ()
	Returns the reference to the neighboring node. More...
void	createQRules (QuadratureType type, Order order, Order volume_order, Order face_order)
	Creates the volume, face and arbitrary qrules based on the orders passed in. More...
void	setVolumeQRule (QBase *qrule, unsigned int dim)
	Set the qrule to be used for volume integration. More...
void	setFaceQRule (QBase *qrule, unsigned int dim)
	Set the qrule to be used for face integration. More...
void	setNeighborQRule (QBase *qrule, unsigned int dim)
	Set the qrule to be used for neighbor integration. More...
void	reinit (const Elem *elem)
	Reinitialize objects (JxW, q_points, ...) for an elements. More...
void	reinitAtPhysical (const Elem *elem, const std::vector< Point > &physical_points)
	Reinitialize the assembly data at specific physical point in the given element. More...
void	reinit (const Elem *elem, const std::vector< Point > &reference_points)
	Reinitialize the assembly data at specific points in the reference element. More...
void	reinit (const Elem *elem, unsigned int side)
	Reinitialize the assembly data on an side of an element. More...
void	reinitElemAndNeighbor (const Elem *elem, unsigned int side, const Elem *neighbor, unsigned int neighbor_side)
	Reinitialize an element and its neighbor along a particular side. More...
void	reinitNeighborAtPhysical (const Elem *neighbor, unsigned int neighbor_side, const std::vector< Point > &physical_points)
	Reinitializes the neighbor at the physical coordinates on neighbor side given. More...
void	reinitNeighborAtPhysical (const Elem *neighbor, const std::vector< Point > &physical_points)
	Reinitializes the neighbor at the physical coordinates within element given. More...
void	reinitNeighbor (const Elem *neighbor, const std::vector< Point > &reference_points)
void	reinit (const Node *node)
	Reinitialize assembly data for a node. More...
void	init (const CouplingMatrix *cm)
	Initialize the Assembly object and set the CouplingMatrix for use throughout. More...
void	init ()
	Deprecated init method. More...
void	initNonlocalCoupling ()
	Create pair of variables requiring nonlocal jacobian contributions. More...
void	prepareJacobianBlock ()
	Sizes and zeroes the Jacobian blocks used for the current element. More...
void	prepareResidual ()
	Sizes and zeroes the residual for the current element. More...
void	prepare ()
void	prepareNonlocal ()
void	prepareVariable (MooseVariableFEBase *var)
	Used for preparing the dense residual and jacobian blocks for one particular variable. More...
void	prepareVariableNonlocal (MooseVariableFEBase *var)
void	prepareNeighbor ()
void	prepareBlock (unsigned int ivar, unsigned jvar, const std::vector< dof_id_type > &dof_indices)
void	prepareBlockNonlocal (unsigned int ivar, unsigned jvar, const std::vector< dof_id_type > &idof_indices, const std::vector< dof_id_type > &jdof_indices)
void	prepareScalar ()
void	prepareOffDiagScalar ()
template<typename T >
void	copyShapes (MooseVariableFE< T > &v)
void	copyShapes (unsigned int var)
template<typename T >
void	copyFaceShapes (MooseVariableFE< T > &v)
void	copyFaceShapes (unsigned int var)
template<typename T >
void	copyNeighborShapes (MooseVariableFE< T > &v)
void	copyNeighborShapes (unsigned int var)
void	addResidual (NumericVector< Number > &residual, TagID tag_id=0)
void	addResidual (const std::map< TagName, TagID > &tags)
void	addResidualNeighbor (NumericVector< Number > &residual, TagID tag_id=0)
void	addResidualNeighbor (const std::map< TagName, TagID > &tags)
void	addResidualScalar (TagID tag_id)
void	addResidualScalar (const std::map< TagName, TagID > &tags)
void	cacheResidual ()
	Takes the values that are currently in _sub_Re and appends them to the cached values. More...
void	cacheResidualContribution (dof_id_type dof, Real value, TagID tag_id)
	Cache individual residual contributions. More...
void	cacheResidualContribution (dof_id_type dof, Real value, const std::set< TagID > &tags)
	Cache individual residual contributions. More...
void	cacheResidualNodes (const DenseVector< Number > &res, std::vector< dof_id_type > &dof_index, TagID tag=0)
	Lets an external class cache residual at a set of nodes. More...
void	cacheResidualNeighbor ()
	Takes the values that are currently in _sub_Ke and appends them to the cached values. More...
void	addCachedResiduals ()
void	addCachedResidual (NumericVector< Number > &residual, TagID tag_id)
	Adds the values that have been cached by calling cacheResidual() and or cacheResidualNeighbor() to the residual. More...
void	setResidual (NumericVector< Number > &residual, TagID tag_id=0)
void	setResidualNeighbor (NumericVector< Number > &residual, TagID tag_id=0)
void	addJacobian ()
void	addJacobianCoupledVarPair (MooseVariableBase *ivar, MooseVariableBase *jvar)
	Adds element matrix for ivar rows and jvar columns. More...
void	addJacobianNonlocal ()
void	addJacobianBlock (SparseMatrix< Number > &jacobian, unsigned int ivar, unsigned int jvar, const DofMap &dof_map, std::vector< dof_id_type > &dof_indices)
void	addJacobianBlockNonlocal (SparseMatrix< Number > &jacobian, unsigned int ivar, unsigned int jvar, const DofMap &dof_map, const std::vector< dof_id_type > &idof_indices, const std::vector< dof_id_type > &jdof_indices)
void	addJacobianNeighbor ()
void	addJacobianNeighbor (SparseMatrix< Number > &jacobian, unsigned int ivar, unsigned int jvar, const DofMap &dof_map, std::vector< dof_id_type > &dof_indices, std::vector< dof_id_type > &neighbor_dof_indices)
void	addJacobianScalar ()
void	addJacobianOffDiagScalar (unsigned int ivar)
void	cacheJacobian ()
	Takes the values that are currently in _sub_Kee and appends them to the cached values. More...
void	cacheJacobianCoupledVarPair (MooseVariableBase *ivar, MooseVariableBase *jvar)
	Caches element matrix for ivar rows and jvar columns. More...
void	cacheJacobianNonlocal ()
	Takes the values that are currently in _sub_Keg and appends them to the cached values. More...
void	cacheJacobianNeighbor ()
	Takes the values that are currently in the neighbor Dense Matrices and appends them to the cached values. More...
void	addCachedJacobian (SparseMatrix< Number > &jacobian)
	Adds the values that have been cached by calling cacheJacobian() and or cacheJacobianNeighbor() to the jacobian matrix. More...
void	addCachedJacobian ()
DenseVector< Number > &	residualBlock (unsigned int var_num, TagID tag_id=0)
DenseVector< Number > &	residualBlockNeighbor (unsigned int var_num, TagID tag_id=0)
DenseMatrix< Number > &	jacobianBlock (unsigned int ivar, unsigned int jvar, TagID tag=0)
DenseMatrix< Number > &	jacobianBlockNonlocal (unsigned int ivar, unsigned int jvar, TagID tag=0)
DenseMatrix< Number > &	jacobianBlockNeighbor (Moose::DGJacobianType type, unsigned int ivar, unsigned int jvar, TagID tag=0)
void	cacheJacobianBlock (DenseMatrix< Number > &jac_block, std::vector< dof_id_type > &idof_indices, std::vector< dof_id_type > &jdof_indices, Real scaling_factor, TagID tag=0)
void	cacheJacobianBlockNonlocal (DenseMatrix< Number > &jac_block, const std::vector< dof_id_type > &idof_indices, const std::vector< dof_id_type > &jdof_indices, Real scaling_factor, TagID tag=0)
std::vector< std::pair< MooseVariableFEBase *, MooseVariableFEBase * > > &	couplingEntries ()
std::vector< std::pair< MooseVariableFEBase *, MooseVariableFEBase * > > &	nonlocalCouplingEntries ()
const VariablePhiValue &	phi () const
template<typename T , ComputeStage compute_stage>
const VariableTestGradientType< T, compute_stage >::type &	adGradPhi (const MooseVariableFE< T > &v) const
const VariablePhiValue &	phi (const MooseVariable &) const
const VariablePhiGradient &	gradPhi () const
const VariablePhiGradient &	gradPhi (const MooseVariable &) const
const VariablePhiSecond &	secondPhi () const
const VariablePhiSecond &	secondPhi (const MooseVariable &) const
const VariablePhiValue &	phiFace () const
const VariablePhiValue &	phiFace (const MooseVariable &) const
const VariablePhiGradient &	gradPhiFace () const
const VariablePhiGradient &	gradPhiFace (const MooseVariable &) const
const VariablePhiSecond &	secondPhiFace (const MooseVariable &) const
const VariablePhiValue &	phiNeighbor (const MooseVariable &) const
const VariablePhiGradient &	gradPhiNeighbor (const MooseVariable &) const
const VariablePhiSecond &	secondPhiNeighbor (const MooseVariable &) const
const VariablePhiValue &	phiFaceNeighbor (const MooseVariable &) const
const VariablePhiGradient &	gradPhiFaceNeighbor (const MooseVariable &) const
const VariablePhiSecond &	secondPhiFaceNeighbor (const MooseVariable &) const
const VectorVariablePhiValue &	phi (const VectorMooseVariable &) const
const VectorVariablePhiGradient &	gradPhi (const VectorMooseVariable &) const
const VectorVariablePhiSecond &	secondPhi (const VectorMooseVariable &) const
const VectorVariablePhiCurl &	curlPhi (const VectorMooseVariable &) const
const VectorVariablePhiValue &	phiFace (const VectorMooseVariable &) const
const VectorVariablePhiGradient &	gradPhiFace (const VectorMooseVariable &) const
const VectorVariablePhiSecond &	secondPhiFace (const VectorMooseVariable &) const
const VectorVariablePhiCurl &	curlPhiFace (const VectorMooseVariable &) const
const VectorVariablePhiValue &	phiNeighbor (const VectorMooseVariable &) const
const VectorVariablePhiGradient &	gradPhiNeighbor (const VectorMooseVariable &) const
const VectorVariablePhiSecond &	secondPhiNeighbor (const VectorMooseVariable &) const
const VectorVariablePhiCurl &	curlPhiNeighbor (const VectorMooseVariable &) const
const VectorVariablePhiValue &	phiFaceNeighbor (const VectorMooseVariable &) const
const VectorVariablePhiGradient &	gradPhiFaceNeighbor (const VectorMooseVariable &) const
const VectorVariablePhiSecond &	secondPhiFaceNeighbor (const VectorMooseVariable &) const
const VectorVariablePhiCurl &	curlPhiFaceNeighbor (const VectorMooseVariable &) const
VariablePhiValue &	phi (const MooseVariable &)
VariablePhiGradient &	gradPhi (const MooseVariable &)
VariablePhiSecond &	secondPhi (const MooseVariable &)
VariablePhiValue &	phiFace (const MooseVariable &)
VariablePhiGradient &	gradPhiFace (const MooseVariable &)
VariablePhiSecond &	secondPhiFace (const MooseVariable &)
VariablePhiValue &	phiNeighbor (const MooseVariable &)
VariablePhiGradient &	gradPhiNeighbor (const MooseVariable &)
VariablePhiSecond &	secondPhiNeighbor (const MooseVariable &)
VariablePhiValue &	phiFaceNeighbor (const MooseVariable &)
VariablePhiGradient &	gradPhiFaceNeighbor (const MooseVariable &)
VariablePhiSecond &	secondPhiFaceNeighbor (const MooseVariable &)
VectorVariablePhiValue &	phi (const VectorMooseVariable &)
VectorVariablePhiGradient &	gradPhi (const VectorMooseVariable &)
VectorVariablePhiSecond &	secondPhi (const VectorMooseVariable &)
VectorVariablePhiCurl &	curlPhi (const VectorMooseVariable &)
VectorVariablePhiValue &	phiFace (const VectorMooseVariable &)
VectorVariablePhiGradient &	gradPhiFace (const VectorMooseVariable &)
VectorVariablePhiSecond &	secondPhiFace (const VectorMooseVariable &)
VectorVariablePhiCurl &	curlPhiFace (const VectorMooseVariable &)
VectorVariablePhiValue &	phiNeighbor (const VectorMooseVariable &)
VectorVariablePhiGradient &	gradPhiNeighbor (const VectorMooseVariable &)
VectorVariablePhiSecond &	secondPhiNeighbor (const VectorMooseVariable &)
VectorVariablePhiCurl &	curlPhiNeighbor (const VectorMooseVariable &)
VectorVariablePhiValue &	phiFaceNeighbor (const VectorMooseVariable &)
VectorVariablePhiGradient &	gradPhiFaceNeighbor (const VectorMooseVariable &)
VectorVariablePhiSecond &	secondPhiFaceNeighbor (const VectorMooseVariable &)
VectorVariablePhiCurl &	curlPhiFaceNeighbor (const VectorMooseVariable &)
template<typename OutputType >
const OutputTools< OutputType >::VariablePhiValue &	fePhi (FEType type)
template<typename OutputType >
const OutputTools< OutputType >::VariablePhiGradient &	feGradPhi (FEType type)
template<typename OutputType >
const VariableTestGradientType< OutputType, ComputeStage::JACOBIAN >::type &	feADGradPhi (FEType type)
template<typename OutputType >
const OutputTools< OutputType >::VariablePhiSecond &	feSecondPhi (FEType type)
template<typename OutputType >
const OutputTools< OutputType >::VariablePhiValue &	fePhiFace (FEType type)
template<typename OutputType >
const OutputTools< OutputType >::VariablePhiGradient &	feGradPhiFace (FEType type)
template<typename OutputType >
const VariableTestGradientType< OutputType, ComputeStage::JACOBIAN >::type &	feADGradPhiFace (FEType type)
template<typename OutputType >
const OutputTools< OutputType >::VariablePhiSecond &	feSecondPhiFace (FEType type)
template<typename OutputType >
const OutputTools< OutputType >::VariablePhiValue &	fePhiNeighbor (FEType type)
template<typename OutputType >
const OutputTools< OutputType >::VariablePhiGradient &	feGradPhiNeighbor (FEType type)
template<typename OutputType >
const OutputTools< OutputType >::VariablePhiSecond &	feSecondPhiNeighbor (FEType type)
template<typename OutputType >
const OutputTools< OutputType >::VariablePhiValue &	fePhiFaceNeighbor (FEType type)
template<typename OutputType >
const OutputTools< OutputType >::VariablePhiGradient &	feGradPhiFaceNeighbor (FEType type)
template<typename OutputType >
const OutputTools< OutputType >::VariablePhiSecond &	feSecondPhiFaceNeighbor (FEType type)
template<typename OutputType >
const OutputTools< OutputType >::VariablePhiCurl &	feCurlPhi (FEType type)
template<typename OutputType >
const OutputTools< OutputType >::VariablePhiCurl &	feCurlPhiFace (FEType type)
template<typename OutputType >
const OutputTools< OutputType >::VariablePhiCurl &	feCurlPhiNeighbor (FEType type)
template<typename OutputType >
const OutputTools< OutputType >::VariablePhiCurl &	feCurlPhiFaceNeighbor (FEType type)
void	cacheJacobianContribution (numeric_index_type i, numeric_index_type j, Real value, TagID tag=0)
	Caches the Jacobian entry 'value', to eventually be added/set in the (i,j) location of the matrix. More...
void	cacheJacobianContribution (numeric_index_type i, numeric_index_type j, Real value, const std::set< TagID > &tags)
void	setCachedJacobianContributions ()
	Sets previously-cached Jacobian values via SparseMatrix::set() calls. More...
void	zeroCachedJacobianContributions ()
	Zero out previously-cached Jacobian rows. More...
void	addCachedJacobianContributions ()
	Adds previously-cached Jacobian values via SparseMatrix::add() calls. More...
void	setXFEM (std::shared_ptr< XFEMInterface > xfem)
	Set the pointer to the XFEM controller object. More...
void	assignDisplacements (std::vector< unsigned > &&disp_numbers)
template<>
const VariableTestGradientType< RealVectorValue, ComputeStage::JACOBIAN >::type &	feADGradPhi (FEType type)
template<>
const VariableTestGradientType< RealVectorValue, ComputeStage::JACOBIAN >::type &	feADGradPhiFace (FEType type)
template<>
const OutputTools< VectorValue< Real > >::VariablePhiValue &	fePhi (FEType type)
template<>
const OutputTools< VectorValue< Real > >::VariablePhiGradient &	feGradPhi (FEType type)
template<>
const OutputTools< VectorValue< Real > >::VariablePhiSecond &	feSecondPhi (FEType type)
template<>
const OutputTools< VectorValue< Real > >::VariablePhiValue &	fePhiFace (FEType type)
template<>
const OutputTools< VectorValue< Real > >::VariablePhiGradient &	feGradPhiFace (FEType type)
template<>
const OutputTools< VectorValue< Real > >::VariablePhiSecond &	feSecondPhiFace (FEType type)
template<>
const OutputTools< VectorValue< Real > >::VariablePhiValue &	fePhiNeighbor (FEType type)
template<>
const OutputTools< VectorValue< Real > >::VariablePhiGradient &	feGradPhiNeighbor (FEType type)
template<>
const OutputTools< VectorValue< Real > >::VariablePhiSecond &	feSecondPhiNeighbor (FEType type)
template<>
const OutputTools< VectorValue< Real > >::VariablePhiValue &	fePhiFaceNeighbor (FEType type)
template<>
const OutputTools< VectorValue< Real > >::VariablePhiGradient &	feGradPhiFaceNeighbor (FEType type)
template<>
const OutputTools< VectorValue< Real > >::VariablePhiSecond &	feSecondPhiFaceNeighbor (FEType type)
template<>
const OutputTools< VectorValue< Real > >::VariablePhiCurl &	feCurlPhi (FEType type)
template<>
const OutputTools< VectorValue< Real > >::VariablePhiCurl &	feCurlPhiFace (FEType type)
template<>
const OutputTools< VectorValue< Real > >::VariablePhiCurl &	feCurlPhiNeighbor (FEType type)
template<>
const OutputTools< VectorValue< Real > >::VariablePhiCurl &	feCurlPhiFaceNeighbor (FEType type)
template<>
const MooseArray< typename Moose::RealType< RESIDUAL >::type > &	adJxW () const
template<>
const OutputTools< VectorValue< Real > >::VariablePhiValue &	fePhi (FEType type)
template<>
const OutputTools< VectorValue< Real > >::VariablePhiGradient &	feGradPhi (FEType type)
template<>
const OutputTools< VectorValue< Real > >::VariablePhiSecond &	feSecondPhi (FEType type)
template<>
const OutputTools< VectorValue< Real > >::VariablePhiValue &	fePhiFace (FEType type)
template<>
const OutputTools< VectorValue< Real > >::VariablePhiGradient &	feGradPhiFace (FEType type)
template<>
const OutputTools< VectorValue< Real > >::VariablePhiSecond &	feSecondPhiFace (FEType type)
template<>
const OutputTools< VectorValue< Real > >::VariablePhiValue &	fePhiNeighbor (FEType type)
template<>
const OutputTools< VectorValue< Real > >::VariablePhiGradient &	feGradPhiNeighbor (FEType type)
template<>
const OutputTools< VectorValue< Real > >::VariablePhiSecond &	feSecondPhiNeighbor (FEType type)
template<>
const OutputTools< VectorValue< Real > >::VariablePhiValue &	fePhiFaceNeighbor (FEType type)
template<>
const OutputTools< VectorValue< Real > >::VariablePhiGradient &	feGradPhiFaceNeighbor (FEType type)
template<>
const OutputTools< VectorValue< Real > >::VariablePhiSecond &	feSecondPhiFaceNeighbor (FEType type)
template<>
const OutputTools< VectorValue< Real > >::VariablePhiCurl &	feCurlPhi (FEType type)
template<>
const OutputTools< VectorValue< Real > >::VariablePhiCurl &	feCurlPhiFace (FEType type)
template<>
const OutputTools< VectorValue< Real > >::VariablePhiCurl &	feCurlPhiNeighbor (FEType type)
template<>
const OutputTools< VectorValue< Real > >::VariablePhiCurl &	feCurlPhiFaceNeighbor (FEType type)
template<>
const MooseArray< typename Moose::RealType< RESIDUAL >::type > &	adJxW () const

Public Attributes
std::map< FEType, bool >	_need_second_derivative
std::map< FEType, bool >	_need_second_derivative_neighbor
std::map< FEType, bool >	_need_curl

Protected Member Functions
void	reinitFE (const Elem *elem)
	Just an internal helper function to reinit the volume FE objects. More...
void	reinitFEFace (const Elem *elem, unsigned int side)
	Just an internal helper function to reinit the face FE objects. More...
void	computeFaceMap (unsigned dim, const std::vector< Real > &qw, const Elem *side)
void	reinitFEFaceNeighbor (const Elem *neighbor, const std::vector< Point > &reference_points)
void	reinitFENeighbor (const Elem *neighbor, const std::vector< Point > &reference_points)
template<ComputeStage compute_stage>
void	setCoordinateTransformation (const QBase *qrule, const ADPoint &q_points, MooseArray< ADReal > &coord)
void	computeCurrentElemVolume ()
void	computeCurrentFaceVolume ()
void	computeCurrentNeighborVolume ()
void	addResidualBlock (NumericVector< Number > &residual, DenseVector< Number > &res_block, const std::vector< dof_id_type > &dof_indices, Real scaling_factor)
void	cacheResidualBlock (std::vector< Real > &cached_residual_values, std::vector< dof_id_type > &cached_residual_rows, DenseVector< Number > &res_block, std::vector< dof_id_type > &dof_indices, Real scaling_factor)
void	setResidualBlock (NumericVector< Number > &residual, DenseVector< Number > &res_block, std::vector< dof_id_type > &dof_indices, Real scaling_factor)
void	addJacobianBlock (SparseMatrix< Number > &jacobian, DenseMatrix< Number > &jac_block, const std::vector< dof_id_type > &idof_indices, const std::vector< dof_id_type > &jdof_indices, Real scaling_factor)
void	clearCachedJacobianContributions ()
	Clear any currently cached jacobian contributions. More...
void	modifyWeightsDueToXFEM (const Elem *elem)
	Update the integration weights for XFEM partial elements. More...
void	modifyFaceWeightsDueToXFEM (const Elem *elem, unsigned int side=0)
	Update the face integration weights for XFEM partial elements. More...
template<typename OutputType >
void	computeGradPhiAD (const Elem *elem, unsigned int n_qp, typename VariableTestGradientType< OutputType, ComputeStage::JACOBIAN >::type &grad_phi, FEGenericBase< OutputType > *fe)
void	resizeMappingObjects (unsigned int n_qp, unsigned int dim)
void	computeAffineMapAD (const Elem *elem, const std::vector< Real > &qw, unsigned int n_qp, FEBase *fe)
void	computeSinglePointMapAD (const Elem *elem, const std::vector< Real > &qw, unsigned p, FEBase *fe)
template<>
void	computeGradPhiAD (const Elem *, unsigned int, typename VariableTestGradientType< RealVectorValue, ComputeStage::JACOBIAN >::type &, FEGenericBase< RealVectorValue > *)

Protected Attributes
SystemBase &	_sys
SubProblem &	_subproblem
const bool	_displaced
const CouplingMatrix *	_cm
	Coupling matrices. More...
const CouplingMatrix &	_nonlocal_cm
const bool &	_computing_jacobian
std::vector< std::pair< MooseVariableFEBase *, MooseVariableFEBase * > >	_cm_ff_entry
	Entries in the coupling matrix for field variables. More...
std::vector< std::pair< MooseVariableFEBase *, MooseVariableScalar * > >	_cm_fs_entry
	Entries in the coupling matrix for field variables vs scalar variables. More...
std::vector< std::pair< MooseVariableScalar *, MooseVariableFEBase * > >	_cm_sf_entry
	Entries in the coupling matrix for scalar variables vs field variables. More...
std::vector< std::pair< MooseVariableScalar *, MooseVariableScalar * > >	_cm_ss_entry
	Entries in the coupling matrix for scalar variables. More...
std::vector< std::pair< MooseVariableFEBase *, MooseVariableFEBase * > >	_cm_nonlocal_entry
	Entries in the coupling matrix for field variables for nonlocal calculations. More...
std::vector< std::vector< std::vector< unsigned char > > >	_jacobian_block_used
	Flag that indicates if the jacobian block was used. More...
std::vector< std::vector< std::vector< unsigned char > > >	_jacobian_block_nonlocal_used
std::vector< std::vector< std::vector< unsigned char > > >	_jacobian_block_neighbor_used
	Flag that indicates if the jacobian block for neighbor was used. More...
const DofMap &	_dof_map
	DOF map. More...
THREAD_ID	_tid
	Thread number (id) More...
MooseMesh &	_mesh
unsigned int	_mesh_dimension
std::shared_ptr< XFEMInterface >	_xfem
	The XFEM controller. More...
std::map< FEType, FEBase * >	_current_fe
	The "volume" fe object that matches the current elem. More...
std::map< FEType, FEBase * >	_current_fe_face
	The "face" fe object that matches the current elem. More...
std::map< FEType, FEBase * >	_current_fe_neighbor
	The "neighbor" fe object that matches the current elem. More...
std::map< FEType, FEBase * >	_current_fe_face_neighbor
	The "neighbor face" fe object that matches the current elem. More...
std::map< FEType, FEVectorBase * >	_current_vector_fe
	The "volume" vector fe object that matches the current elem. More...
std::map< FEType, FEVectorBase * >	_current_vector_fe_face
	The "face" vector fe object that matches the current elem. More...
std::map< FEType, FEVectorBase * >	_current_vector_fe_neighbor
	The "neighbor" vector fe object that matches the current elem. More...
std::map< FEType, FEVectorBase * >	_current_vector_fe_face_neighbor
	The "neighbor face" vector fe object that matches the current elem. More...
std::map< unsigned int, std::map< FEType, FEBase * > >	_fe
	Each dimension's actual fe objects indexed on type. More...
std::map< unsigned int, std::map< FEType, FEVectorBase * > >	_vector_fe
	Each dimension's actual vector fe objects indexed on type. More...
std::map< unsigned int, FEBase ** >	_holder_fe_helper
	Each dimension's helper objects. More...
FEBase *	_current_fe_helper
	The current helper object for transforming coordinates. More...
QBase *	_current_qrule
	The current current quadrature rule being used (could be either volumetric or arbitrary - for dirac kernels) More...
QBase *	_current_qrule_volume
	The current volumetric quadrature for the element. More...
ArbitraryQuadrature *	_current_qrule_arbitrary
	The current arbitrary quadrature rule used within the element interior. More...
MooseArray< Point >	_current_q_points
	The current list of quadrature points. More...
MooseArray< Real >	_current_JxW
	The current list of transformed jacobian weights. More...
Moose::CoordinateSystemType	_coord_type
	The coordinate system. More...
MooseArray< Real >	_coord
	The current coordinate transformation coefficients. More...
MooseArray< DualReal >	_ad_coord
	The AD version of the current coordinate transformation coefficients. More...
std::map< unsigned int, QBase * >	_holder_qrule_volume
	Holds volume qrules for each dimension. More...
std::map< unsigned int, ArbitraryQuadrature * >	_holder_qrule_arbitrary
	Holds arbitrary qrules for each dimension. More...
std::map< unsigned int, const std::vector< Point > * >	_holder_q_points
	Holds pointers to the dimension's q_points. More...
std::map< unsigned int, const std::vector< Real > * >	_holder_JxW
	Holds pointers to the dimension's transformed jacobian weights. More...
std::map< unsigned int, std::map< FEType, FEBase * > >	_fe_face
	types of finite elements More...
std::map< unsigned int, std::map< FEType, FEVectorBase * > >	_vector_fe_face
	types of vector finite elements More...
std::map< unsigned int, FEBase ** >	_holder_fe_face_helper
	Each dimension's helper objects. More...
FEBase *	_current_fe_face_helper
	helper object for transforming coordinates More...
QBase *	_current_qrule_face
	quadrature rule used on faces More...
ArbitraryQuadrature *	_current_qface_arbitrary
	The current arbitrary quadrature rule used on element faces. More...
MooseArray< Point >	_current_q_points_face
	The current quadrature points on a face. More...
MooseArray< Real >	_current_JxW_face
	The current transformed jacobian weights on a face. More...
MooseArray< Point >	_current_normals
	The current Normal vectors at the quadrature points. More...
std::map< unsigned int, QBase * >	_holder_qrule_face
	Holds face qrules for each dimension. More...
std::map< unsigned int, ArbitraryQuadrature * >	_holder_qface_arbitrary
	Holds arbitrary face qrules for each dimension. More...
std::map< unsigned int, const std::vector< Point > * >	_holder_q_points_face
	Holds pointers to the dimension's q_points on a face. More...
std::map< unsigned int, const std::vector< Real > * >	_holder_JxW_face
	Holds pointers to the dimension's transformed jacobian weights on a face. More...
std::map< unsigned int, const std::vector< Point > * >	_holder_normals
	Holds pointers to the dimension's normal vectors. More...
std::map< unsigned int, std::map< FEType, FEBase * > >	_fe_neighbor
	types of finite elements More...
std::map< unsigned int, std::map< FEType, FEBase * > >	_fe_face_neighbor
std::map< unsigned int, std::map< FEType, FEVectorBase * > >	_vector_fe_neighbor
std::map< unsigned int, std::map< FEType, FEVectorBase * > >	_vector_fe_face_neighbor
std::map< unsigned int, FEBase ** >	_holder_fe_neighbor_helper
	Each dimension's helper objects. More...
std::map< unsigned int, FEBase ** >	_holder_fe_face_neighbor_helper
QBase *	_current_qrule_neighbor
	quadrature rule used on neighbors More...
std::map< unsigned int, ArbitraryQuadrature * >	_holder_qrule_neighbor
	Holds arbitrary qrules for each dimension. More...
MooseArray< Real >	_current_JxW_neighbor
	The current transformed jacobian weights on a neighbor's face. More...
MooseArray< Real >	_coord_neighbor
	The current coordinate transformation coefficients. More...
const Elem *	_current_elem
	The current "element" we are currently on. More...
SubdomainID	_current_subdomain_id
	The current subdomain ID. More...
Real	_current_elem_volume
	Volume of the current element. More...
unsigned int	_current_side
	The current side of the selected element (valid only when working with sides) More...
const Elem *	_current_side_elem
	The current "element" making up the side we are currently on. More...
Real	_current_side_volume
	Volume of the current side element. More...
const Elem *	_current_neighbor_elem
	The current neighbor "element". More...
SubdomainID	_current_neighbor_subdomain_id
	The current neighbor subdomain ID. More...
unsigned int	_current_neighbor_side
	The current side of the selected neighboring element (valid only when working with sides) More...
const Elem *	_current_neighbor_side_elem
	The current side element of the ncurrent neighbor element. More...
bool	_need_neighbor_elem_volume
	true is apps need to compute neighbor element volume More...
Real	_current_neighbor_volume
	Volume of the current neighbor. More...
const Node *	_current_node
	The current node we are working with. More...
const Node *	_current_neighbor_node
	The current neighboring node we are working with. More...
bool	_current_elem_volume_computed
	Boolean to indicate whether current element volumes has been computed. More...
bool	_current_side_volume_computed
	Boolean to indicate whether current element side volumes has been computed. More...
MooseArray< Point >	_current_physical_points
	This will be filled up with the physical points passed into reinitAtPhysical() if it is called. Invalid at all other times. More...
std::vector< std::vector< DenseVector< Number > > >	_sub_Re
	residual contributions for each variable from the element More...
std::vector< std::vector< DenseVector< Number > > >	_sub_Rn
	residual contributions for each variable from the neighbor More...
DenseVector< Number >	_tmp_Re
	auxiliary vector for scaling residuals (optimization to avoid expensive construction/destruction) More...
std::vector< std::vector< std::vector< DenseMatrix< Number > > > >	_sub_Kee
	jacobian contributions <Tag, ivar, jvar> More...
std::vector< std::vector< std::vector< DenseMatrix< Number > > > >	_sub_Keg
std::vector< std::vector< std::vector< DenseMatrix< Number > > > >	_sub_Ken
	jacobian contributions from the element and neighbor <Tag, ivar, jvar> More...
std::vector< std::vector< std::vector< DenseMatrix< Number > > > >	_sub_Kne
	jacobian contributions from the neighbor and element <Tag, ivar, jvar> More...
std::vector< std::vector< std::vector< DenseMatrix< Number > > > >	_sub_Knn
	jacobian contributions from the neighbor <Tag, ivar, jvar> More...
DenseMatrix< Number >	_tmp_Ke
	auxiliary matrix for scaling jacobians (optimization to avoid expensive construction/destruction) More...
VariablePhiValue	_phi
VariablePhiGradient	_grad_phi
VariablePhiSecond	_second_phi
VariablePhiValue	_phi_face
VariablePhiGradient	_grad_phi_face
VariablePhiSecond	_second_phi_face
VariablePhiValue	_phi_neighbor
VariablePhiGradient	_grad_phi_neighbor
VariablePhiSecond	_second_phi_neighbor
VariablePhiValue	_phi_face_neighbor
VariablePhiGradient	_grad_phi_face_neighbor
VariablePhiSecond	_second_phi_face_neighbor
VectorVariablePhiValue	_vector_phi
VectorVariablePhiGradient	_vector_grad_phi
VectorVariablePhiSecond	_vector_second_phi
VectorVariablePhiCurl	_vector_curl_phi
VectorVariablePhiValue	_vector_phi_face
VectorVariablePhiGradient	_vector_grad_phi_face
VectorVariablePhiSecond	_vector_second_phi_face
VectorVariablePhiCurl	_vector_curl_phi_face
VectorVariablePhiValue	_vector_phi_neighbor
VectorVariablePhiGradient	_vector_grad_phi_neighbor
VectorVariablePhiSecond	_vector_second_phi_neighbor
VectorVariablePhiCurl	_vector_curl_phi_neighbor
VectorVariablePhiValue	_vector_phi_face_neighbor
VectorVariablePhiGradient	_vector_grad_phi_face_neighbor
VectorVariablePhiSecond	_vector_second_phi_face_neighbor
VectorVariablePhiCurl	_vector_curl_phi_face_neighbor
std::map< FEType, FEShapeData * >	_fe_shape_data
	Shape function values, gradients, second derivatives for each FE type. More...
std::map< FEType, FEShapeData * >	_fe_shape_data_face
std::map< FEType, FEShapeData * >	_fe_shape_data_neighbor
std::map< FEType, FEShapeData * >	_fe_shape_data_face_neighbor
std::map< FEType, VectorFEShapeData * >	_vector_fe_shape_data
	Shape function values, gradients, second derivatives for each vector FE type. More...
std::map< FEType, VectorFEShapeData * >	_vector_fe_shape_data_face
std::map< FEType, VectorFEShapeData * >	_vector_fe_shape_data_neighbor
std::map< FEType, VectorFEShapeData * >	_vector_fe_shape_data_face_neighbor
std::map< FEType, typename VariableTestGradientType< Real, ComputeStage::JACOBIAN >::type >	_ad_grad_phi_data
std::map< FEType, typename VariableTestGradientType< RealVectorValue, ComputeStage::JACOBIAN >::type >	_ad_vector_grad_phi_data
std::map< FEType, typename VariableTestGradientType< Real, ComputeStage::JACOBIAN >::type >	_ad_grad_phi_data_face
std::map< FEType, typename VariableTestGradientType< RealVectorValue, ComputeStage::JACOBIAN >::type >	_ad_vector_grad_phi_data_face
std::vector< std::vector< Real > >	_cached_residual_values
	Values cached by calling cacheResidual() (the first vector is for TIME vs NONTIME) More...
std::vector< std::vector< dof_id_type > >	_cached_residual_rows
	Where the cached values should go (the first vector is for TIME vs NONTIME) More...
unsigned int	_max_cached_residuals
std::vector< std::vector< Real > >	_cached_jacobian_values
	Values cached by calling cacheJacobian() More...
std::vector< std::vector< dof_id_type > >	_cached_jacobian_rows
	Row where the corresponding cached value should go. More...
std::vector< std::vector< dof_id_type > >	_cached_jacobian_cols
	Column where the corresponding cached value should go. More...
unsigned int	_max_cached_jacobians
unsigned int	_block_diagonal_matrix
	Will be true if our preconditioning matrix is a block-diagonal matrix. Which means that we can take some shortcuts. More...
std::vector< dof_id_type >	_temp_dof_indices
	Temporary work vector to keep from reallocating it. More...
std::vector< Point >	_temp_reference_points
	Temporary work data for reinitAtPhysical() More...
std::vector< std::vector< Real > >	_cached_jacobian_contribution_vals
	Storage for cached Jacobian entries. More...
std::vector< std::vector< numeric_index_type > >	_cached_jacobian_contribution_rows
std::vector< std::vector< numeric_index_type > >	_cached_jacobian_contribution_cols
std::vector< VectorValue< DualReal > >	_ad_dxyzdxi_map
	AD quantities. More...
std::vector< VectorValue< DualReal > >	_ad_dxyzdeta_map
std::vector< VectorValue< DualReal > >	_ad_dxyzdzeta_map
std::vector< VectorValue< DualReal > >	_ad_d2xyzdxi2_map
std::vector< VectorValue< DualReal > >	_ad_d2xyzdxideta_map
std::vector< VectorValue< DualReal > >	_ad_d2xyzdeta2_map
std::vector< DualReal >	_ad_jac
MooseArray< DualReal >	_ad_JxW
MooseArray< VectorValue< DualReal > >	_ad_q_points
std::vector< DualReal >	_ad_dxidx_map
std::vector< DualReal >	_ad_dxidy_map
std::vector< DualReal >	_ad_dxidz_map
std::vector< DualReal >	_ad_detadx_map
std::vector< DualReal >	_ad_detady_map
std::vector< DualReal >	_ad_detadz_map
std::vector< DualReal >	_ad_dzetadx_map
std::vector< DualReal >	_ad_dzetady_map
std::vector< DualReal >	_ad_dzetadz_map
MooseArray< DualReal >	_ad_JxW_face
MooseArray< VectorValue< DualReal > >	_ad_normals
MooseArray< VectorValue< DualReal > >	_ad_q_points_face
MooseArray< Real >	_curvatures
MooseArray< DualReal >	_ad_curvatures
std::vector< unsigned >	_displacements
bool	_calculate_xyz
bool	_calculate_face_xyz
bool	_calculate_curvatures

Detailed Description

Keeps track of stuff related to assembling.

Definition at line 63 of file Assembly.h.

Constructor & Destructor Documentation

Assembly()

Assembly::Assembly	(	SystemBase &	sys,
		THREAD_ID	tid
	)

Definition at line 36 of file Assembly.C.

  : _sys(sys),
    _subproblem(_sys.subproblem()),
    _displaced(dynamic_cast<DisplacedSystem *>(&sys) ? true : false),
    _nonlocal_cm(_subproblem.nonlocalCouplingMatrix()),
    _computing_jacobian(_subproblem.currentlyComputingJacobian()),
    _dof_map(_sys.dofMap()),
    _tid(tid),
    _mesh(sys.mesh()),
    _mesh_dimension(_mesh.dimension()),
    _current_qrule(NULL),
    _current_qrule_volume(NULL),
    _current_qrule_arbitrary(NULL),
    _coord_type(Moose::COORD_XYZ),
    _current_qrule_face(NULL),
    _current_qface_arbitrary(NULL),
    _current_qrule_neighbor(NULL),

    _current_elem(NULL),
    _current_elem_volume(0),
    _current_side(0),
    _current_side_elem(NULL),
    _current_side_volume(0),
    _current_neighbor_elem(NULL),
    _current_neighbor_side(0),
    _current_neighbor_side_elem(NULL),
    _need_neighbor_elem_volume(false),
    _current_neighbor_volume(0),
    _current_node(NULL),
    _current_neighbor_node(NULL),
    _current_elem_volume_computed(false),
    _current_side_volume_computed(false),

    _cached_residual_values(2), // The 2 is for TIME and NONTIME
    _cached_residual_rows(2),   // The 2 is for TIME and NONTIME

    _max_cached_residuals(0),
    _max_cached_jacobians(0),
    _block_diagonal_matrix(false),
    _calculate_xyz(false),
    _calculate_face_xyz(false),
    _calculate_curvatures(false)
{
  Order helper_order = _mesh.hasSecondOrderElements() ? SECOND : FIRST;
  // Build fe's for the helpers
  buildFE(FEType(helper_order, LAGRANGE));
  buildFaceFE(FEType(helper_order, LAGRANGE));
  buildNeighborFE(FEType(helper_order, LAGRANGE));
  buildFaceNeighborFE(FEType(helper_order, LAGRANGE));

  // Build an FE helper object for this type for each dimension up to the dimension of the current
  // mesh
  for (unsigned int dim = 0; dim <= _mesh_dimension; dim++)
  {
    _holder_fe_helper[dim] = &_fe[dim][FEType(helper_order, LAGRANGE)];
    (*_holder_fe_helper[dim])->get_phi();
    (*_holder_fe_helper[dim])->get_dphi();
    (*_holder_fe_helper[dim])->get_xyz();
    (*_holder_fe_helper[dim])->get_JxW();

    _holder_fe_face_helper[dim] = &_fe_face[dim][FEType(helper_order, LAGRANGE)];
    (*_holder_fe_face_helper[dim])->get_phi();
    (*_holder_fe_face_helper[dim])->get_dphi();
    (*_holder_fe_face_helper[dim])->get_xyz();
    (*_holder_fe_face_helper[dim])->get_JxW();
    (*_holder_fe_face_helper[dim])->get_normals();

    _holder_fe_face_neighbor_helper[dim] = &_fe_face_neighbor[dim][FEType(helper_order, LAGRANGE)];
    (*_holder_fe_face_neighbor_helper[dim])->get_xyz();
    (*_holder_fe_face_neighbor_helper[dim])->get_JxW();
    (*_holder_fe_face_neighbor_helper[dim])->get_normals();

    _holder_fe_neighbor_helper[dim] = &_fe_neighbor[dim][FEType(helper_order, LAGRANGE)];
    (*_holder_fe_neighbor_helper[dim])->get_xyz();
    (*_holder_fe_neighbor_helper[dim])->get_JxW();
  }
}

~Assembly()

Assembly::~Assembly ( )

virtual

Definition at line 114 of file Assembly.C.

{
  for (unsigned int dim = 0; dim <= _mesh_dimension; dim++)
    for (auto & it : _fe[dim])
      delete it.second;

  for (unsigned int dim = 0; dim <= _mesh_dimension; dim++)
    for (auto & it : _fe_face[dim])
      delete it.second;

  for (unsigned int dim = 0; dim <= _mesh_dimension; dim++)
    for (auto & it : _fe_neighbor[dim])
      delete it.second;

  for (unsigned int dim = 0; dim <= _mesh_dimension; dim++)
    for (auto & it : _fe_face_neighbor[dim])
      delete it.second;

  for (unsigned int dim = 0; dim <= _mesh_dimension; dim++)
    for (auto & it : _vector_fe[dim])
      delete it.second;

  for (unsigned int dim = 0; dim <= _mesh_dimension; dim++)
    for (auto & it : _vector_fe_face[dim])
      delete it.second;

  for (unsigned int dim = 0; dim <= _mesh_dimension; dim++)
    for (auto & it : _vector_fe_neighbor[dim])
      delete it.second;

  for (unsigned int dim = 0; dim <= _mesh_dimension; dim++)
    for (auto & it : _vector_fe_face_neighbor[dim])
      delete it.second;

  for (auto & it : _holder_qrule_volume)
    delete it.second;

  for (auto & it : _holder_qrule_arbitrary)
    delete it.second;

  for (auto & it : _holder_qface_arbitrary)
    delete it.second;

  for (auto & it : _holder_qrule_face)
    delete it.second;

  for (auto & it : _holder_qrule_neighbor)
    delete it.second;

  for (auto & it : _fe_shape_data)
    delete it.second;

  for (auto & it : _fe_shape_data_face)
    delete it.second;

  for (auto & it : _fe_shape_data_neighbor)
    delete it.second;

  for (auto & it : _fe_shape_data_face_neighbor)
    delete it.second;

  for (auto & it : _vector_fe_shape_data)
    delete it.second;

  for (auto & it : _vector_fe_shape_data_face)
    delete it.second;

  for (auto & it : _vector_fe_shape_data_neighbor)
    delete it.second;

  for (auto & it : _vector_fe_shape_data_face_neighbor)
    delete it.second;

  for (auto & it : _ad_grad_phi_data)
    it.second.release();

  for (auto & it : _ad_vector_grad_phi_data)
    it.second.release();

  for (auto & it : _ad_grad_phi_data_face)
    it.second.release();

  for (auto & it : _ad_vector_grad_phi_data_face)
    it.second.release();

  delete _current_side_elem;
  delete _current_neighbor_side_elem;

  _current_physical_points.release();

  _coord.release();
  _coord_neighbor.release();

  _ad_JxW.release();
  _ad_q_points.release();
  _ad_JxW_face.release();
  _ad_normals.release();
  _ad_q_points_face.release();
  _curvatures.release();
  _ad_curvatures.release();
  _ad_coord.release();
}

Member Function Documentation

adCoordTransformation()

template<ComputeStage compute_stage>

const MooseArray<ADReal>& Assembly::adCoordTransformation ( ) const

inline

Returns the reference to the AD version of the coordinate transformation coefficients.

Returns

A reference. Make sure to store this as a reference!

Definition at line 263 of file Assembly.h.

  {
    return _coord;
  }

adCurvatures()

template<ComputeStage compute_stage>

template const MooseArray< typename Moose::RealType< RESIDUAL >::type > & Assembly::adCurvatures< RESIDUAL >

(

)

const

Definition at line 3225 of file Assembly.C.

{
  _calculate_curvatures = true;
  for (unsigned int dim = 0; dim <= _mesh_dimension; dim++)
    (*_holder_fe_face_helper.at(dim))->get_curvatures();
  return _curvatures;
}

addCachedJacobian() [1/2]

void Assembly::addCachedJacobian

(

SparseMatrix< Number > &

jacobian

)

Adds the values that have been cached by calling cacheJacobian() and or cacheJacobianNeighbor() to the jacobian matrix.

Note that this will also clear the cache.

Definition at line 2599 of file Assembly.C.

{
  mooseDeprecated(" Please use addCachedJacobian() ");

  addCachedJacobian();
}

addCachedJacobian() [2/2]

void Assembly::addCachedJacobian

(

)

Definition at line 2607 of file Assembly.C.

Referenced by addCachedJacobian().

{
  if (!_subproblem.checkNonlocalCouplingRequirement())
  {
    mooseAssert(_cached_jacobian_rows.size() == _cached_jacobian_cols.size(),
                "Error: Cached data sizes MUST be the same!");
    for (MooseIndex(_cached_jacobian_rows) i = 0; i < _cached_jacobian_rows.size(); i++)
      mooseAssert(_cached_jacobian_rows[i].size() == _cached_jacobian_cols[i].size(),
                  "Error: Cached data sizes MUST be the same for a given tag!");
  }

  for (MooseIndex(_cached_jacobian_rows) i = 0; i < _cached_jacobian_rows.size(); i++)
    if (_sys.hasMatrix(i))
      for (MooseIndex(_cached_jacobian_rows[i]) j = 0; j < _cached_jacobian_rows[i].size(); j++)
        _sys.getMatrix(i).add(_cached_jacobian_rows[i][j],
                              _cached_jacobian_cols[i][j],
                              _cached_jacobian_values[i][j]);

  for (MooseIndex(_cached_jacobian_rows) i = 0; i < _cached_jacobian_rows.size(); i++)
  {
    if (!_sys.hasMatrix(i))
      continue;

    if (_max_cached_jacobians < _cached_jacobian_values[i].size())
      _max_cached_jacobians = _cached_jacobian_values[i].size();

    // Try to be more efficient from now on
    // The 2 is just a fudge factor to keep us from having to grow the vector during assembly
    _cached_jacobian_values[i].clear();
    _cached_jacobian_values[i].reserve(_max_cached_jacobians * 2);

    _cached_jacobian_rows[i].clear();
    _cached_jacobian_rows[i].reserve(_max_cached_jacobians * 2);

    _cached_jacobian_cols[i].clear();
    _cached_jacobian_cols[i].reserve(_max_cached_jacobians * 2);
  }
}

addCachedJacobianContributions()

void Assembly::addCachedJacobianContributions

(

)

Adds previously-cached Jacobian values via SparseMatrix::add() calls.

Definition at line 2979 of file Assembly.C.

Referenced by NonlinearSystemBase::computeJacobianInternal(), ComputeNodalKernelBCJacobiansThread::onNode(), and ComputeNodalKernelJacobiansThread::onNode().

{
  for (MooseIndex(_cached_jacobian_contribution_rows) tag = 0;
       tag < _cached_jacobian_contribution_rows.size();
       tag++)
    if (_sys.hasMatrix(tag))
    {
      // TODO: Use SparseMatrix::set_values() for efficiency
      for (MooseIndex(_cached_jacobian_contribution_vals[tag]) i = 0;
           i < _cached_jacobian_contribution_vals[tag].size();
           ++i)
        _sys.getMatrix(tag).add(_cached_jacobian_contribution_rows[tag][i],
                                _cached_jacobian_contribution_cols[tag][i],
                                _cached_jacobian_contribution_vals[tag][i]);
    }

  clearCachedJacobianContributions();
}

addCachedResidual()

void Assembly::addCachedResidual	(	NumericVector< Number > &	residual,
		TagID	tag_id
	)

Adds the values that have been cached by calling cacheResidual() and or cacheResidualNeighbor() to the residual.

Note that this will also clear the cache.

Definition at line 2442 of file Assembly.C.

Referenced by addCachedResiduals().

{
  if (!_sys.hasVector(tag_id))
  {
    // Only clean up things when tag exists
    if (_subproblem.vectorTagExists(tag_id))
    {
      _cached_residual_values[tag_id].clear();
      _cached_residual_rows[tag_id].clear();
    }
    return;
  }

  std::vector<Real> & cached_residual_values = _cached_residual_values[tag_id];
  std::vector<dof_id_type> & cached_residual_rows = _cached_residual_rows[tag_id];

  mooseAssert(cached_residual_values.size() == cached_residual_rows.size(),
              "Number of cached residuals and number of rows must match!");
  if (cached_residual_values.size())
    residual.add_vector(cached_residual_values, cached_residual_rows);

  if (_max_cached_residuals < cached_residual_values.size())
    _max_cached_residuals = cached_residual_values.size();

  // Try to be more efficient from now on
  // The 2 is just a fudge factor to keep us from having to grow the vector during assembly
  cached_residual_values.clear();
  cached_residual_values.reserve(_max_cached_residuals * 2);

  cached_residual_rows.clear();
  cached_residual_rows.reserve(_max_cached_residuals * 2);
}

addCachedResiduals()

void Assembly::addCachedResiduals

(

)

Definition at line 2427 of file Assembly.C.

{
  for (MooseIndex(_cached_residual_values) tag = 0; tag < _cached_residual_values.size(); tag++)
  {
    if (!_sys.hasVector(tag))
    {
      _cached_residual_values[tag].clear();
      _cached_residual_rows[tag].clear();
      continue;
    }
    addCachedResidual(_sys.getVector(tag), tag);
  }
}

addJacobian()

void Assembly::addJacobian

(

)

Definition at line 2661 of file Assembly.C.

{
  for (const auto & it : _cm_ff_entry)
    addJacobianCoupledVarPair(it.first, it.second);

  for (const auto & it : _cm_sf_entry)
    addJacobianCoupledVarPair(it.first, it.second);

  for (const auto & it : _cm_fs_entry)
    addJacobianCoupledVarPair(it.first, it.second);
}

addJacobianBlock() [1/2]

void Assembly::addJacobianBlock	(	SparseMatrix< Number > &	jacobian,
		unsigned int	ivar,
		unsigned int	jvar,
		const DofMap &	dof_map,
		std::vector< dof_id_type > &	dof_indices
	)

Definition at line 2812 of file Assembly.C.

Referenced by addJacobianCoupledVarPair(), addJacobianNeighbor(), and addJacobianNonlocal().

{
  DenseMatrix<Number> & ke = jacobianBlock(ivar, jvar);

  // stick it into the matrix
  std::vector<dof_id_type> di(dof_indices);
  dof_map.constrain_element_matrix(ke, di, false);

  Real scaling_factor = _sys.getVariable(_tid, ivar).scalingFactor();
  if (scaling_factor != 1.0)
  {
    _tmp_Ke = ke;
    _tmp_Ke *= scaling_factor;
    jacobian.add_matrix(_tmp_Ke, di);
  }
  else
    jacobian.add_matrix(ke, di);
}

addJacobianBlock() [2/2]

void Assembly::addJacobianBlock ( SparseMatrix< Number > &  jacobian, DenseMatrix< Number > &  jac_block, const std::vector< dof_id_type > &  idof_indices, const std::vector< dof_id_type > &  jdof_indices, Real  scaling_factor  )

protected

Definition at line 2516 of file Assembly.C.

{
  if ((idof_indices.size() > 0) && (jdof_indices.size() > 0) && jac_block.n() && jac_block.m())
  {
    std::vector<dof_id_type> di(idof_indices);
    std::vector<dof_id_type> dj(jdof_indices);
    _dof_map.constrain_element_matrix(jac_block, di, dj, false);

    if (scaling_factor != 1.0)
    {
      _tmp_Ke = jac_block;
      _tmp_Ke *= scaling_factor;
      jacobian.add_matrix(_tmp_Ke, di, dj);
    }
    else
      jacobian.add_matrix(jac_block, di, dj);
  }
}

addJacobianBlockNonlocal()

void Assembly::addJacobianBlockNonlocal	(	SparseMatrix< Number > &	jacobian,
		unsigned int	ivar,
		unsigned int	jvar,
		const DofMap &	dof_map,
		const std::vector< dof_id_type > &	idof_indices,
		const std::vector< dof_id_type > &	jdof_indices
	)

Definition at line 2836 of file Assembly.C.

{
  DenseMatrix<Number> & keg = jacobianBlockNonlocal(ivar, jvar);

  std::vector<dof_id_type> di(idof_indices);
  std::vector<dof_id_type> dg(jdof_indices);
  dof_map.constrain_element_matrix(keg, di, dg, false);

  Real scaling_factor = _sys.getVariable(_tid, ivar).scalingFactor();
  if (scaling_factor != 1.0)
  {
    _tmp_Ke = keg;
    _tmp_Ke *= scaling_factor;
    jacobian.add_matrix(_tmp_Ke, di, dg);
  }
  else
    jacobian.add_matrix(keg, di, dg);
}

addJacobianCoupledVarPair()

void Assembly::addJacobianCoupledVarPair ( MooseVariableBase *  ivar, MooseVariableBase *  jvar  )

inline

Adds element matrix for ivar rows and jvar columns.

Definition at line 2647 of file Assembly.C.

Referenced by addJacobian(), addJacobianOffDiagScalar(), and addJacobianScalar().

{
  auto i = ivar->number();
  auto j = jvar->number();
  for (MooseIndex(_jacobian_block_used) tag = 0; tag < _jacobian_block_used.size(); tag++)
    if (_jacobian_block_used[tag][i][j] && _sys.hasMatrix(tag))
      addJacobianBlock(_sys.getMatrix(tag),
                       jacobianBlock(i, j, tag),
                       ivar->dofIndices(),
                       jvar->dofIndices(),
                       ivar->scalingFactor());
}

addJacobianNeighbor() [1/2]

void Assembly::addJacobianNeighbor

(

)

Definition at line 2695 of file Assembly.C.

{
  for (const auto & it : _cm_ff_entry)
  {
    auto ivar = it.first;
    auto jvar = it.second;
    auto i = ivar->number();
    auto j = jvar->number();
    for (MooseIndex(_jacobian_block_neighbor_used) tag = 0;
         tag < _jacobian_block_neighbor_used.size();
         tag++)
      if (_jacobian_block_neighbor_used[tag][i][j] && _sys.hasMatrix(tag))
      {
        addJacobianBlock(_sys.getMatrix(tag),
                         jacobianBlockNeighbor(Moose::ElementNeighbor, i, j, tag),
                         ivar->dofIndices(),
                         jvar->dofIndicesNeighbor(),
                         ivar->scalingFactor());

        addJacobianBlock(_sys.getMatrix(tag),
                         jacobianBlockNeighbor(Moose::NeighborElement, i, j, tag),
                         ivar->dofIndicesNeighbor(),
                         jvar->dofIndices(),
                         ivar->scalingFactor());

        addJacobianBlock(_sys.getMatrix(tag),
                         jacobianBlockNeighbor(Moose::NeighborNeighbor, i, j, tag),
                         ivar->dofIndicesNeighbor(),
                         jvar->dofIndicesNeighbor(),
                         ivar->scalingFactor());
      }
  }
}

addJacobianNeighbor() [2/2]

void Assembly::addJacobianNeighbor	(	SparseMatrix< Number > &	jacobian,
		unsigned int	ivar,
		unsigned int	jvar,
		const DofMap &	dof_map,
		std::vector< dof_id_type > &	dof_indices,
		std::vector< dof_id_type > &	neighbor_dof_indices
	)

Definition at line 2861 of file Assembly.C.

{
  DenseMatrix<Number> & kee = jacobianBlock(ivar, jvar);
  DenseMatrix<Number> & ken = jacobianBlockNeighbor(Moose::ElementNeighbor, ivar, jvar);
  DenseMatrix<Number> & kne = jacobianBlockNeighbor(Moose::NeighborElement, ivar, jvar);
  DenseMatrix<Number> & knn = jacobianBlockNeighbor(Moose::NeighborNeighbor, ivar, jvar);

  std::vector<dof_id_type> di(dof_indices);
  std::vector<dof_id_type> dn(neighbor_dof_indices);
  // stick it into the matrix
  dof_map.constrain_element_matrix(kee, di, false);
  dof_map.constrain_element_matrix(ken, di, dn, false);
  dof_map.constrain_element_matrix(kne, dn, di, false);
  dof_map.constrain_element_matrix(knn, dn, false);

  Real scaling_factor = _sys.getVariable(_tid, ivar).scalingFactor();
  if (scaling_factor != 1.0)
  {
    _tmp_Ke = ken;
    _tmp_Ke *= scaling_factor;
    jacobian.add_matrix(_tmp_Ke, di, dn);

    _tmp_Ke = kne;
    _tmp_Ke *= scaling_factor;
    jacobian.add_matrix(_tmp_Ke, dn, di);

    _tmp_Ke = knn;
    _tmp_Ke *= scaling_factor;
    jacobian.add_matrix(_tmp_Ke, dn);
  }
  else
  {
    jacobian.add_matrix(ken, di, dn);
    jacobian.add_matrix(kne, dn, di);
    jacobian.add_matrix(knn, dn);
  }
}

addJacobianNonlocal()

void Assembly::addJacobianNonlocal

(

)

Definition at line 2674 of file Assembly.C.

{
  for (const auto & it : _cm_nonlocal_entry)
  {
    auto ivar = it.first;
    auto jvar = it.second;
    auto i = ivar->number();
    auto j = jvar->number();
    for (MooseIndex(_jacobian_block_nonlocal_used) tag = 0;
         tag < _jacobian_block_nonlocal_used.size();
         tag++)
      if (_jacobian_block_nonlocal_used[tag][i][j] && _sys.hasMatrix(tag))
        addJacobianBlock(_sys.getMatrix(tag),
                         jacobianBlockNonlocal(i, j, tag),
                         ivar->dofIndices(),
                         jvar->allDofIndices(),
                         ivar->scalingFactor());
  }
}

addJacobianOffDiagScalar()

void Assembly::addJacobianOffDiagScalar

(

unsigned int

ivar

)

Definition at line 2912 of file Assembly.C.

{
  const std::vector<MooseVariableFEBase *> & vars = _sys.getVariables(_tid);
  MooseVariableScalar & var_i = _sys.getScalarVariable(_tid, ivar);
  for (const auto & var_j : vars)
    addJacobianCoupledVarPair(&var_i, var_j);
}

addJacobianScalar()

void Assembly::addJacobianScalar

(

)

Definition at line 2905 of file Assembly.C.

{
  for (const auto & it : _cm_ss_entry)
    addJacobianCoupledVarPair(it.first, it.second);
}

addResidual() [1/2]

void Assembly::addResidual	(	NumericVector< Number > &	residual,
		TagID	tag_id = 0
	)

Definition at line 2310 of file Assembly.C.

Referenced by addResidual().

{
  const std::vector<MooseVariableFEBase *> & vars = _sys.getVariables(_tid);
  for (const auto & var : vars)
    addResidualBlock(
        residual, _sub_Re[tag_id][var->number()], var->dofIndices(), var->scalingFactor());
}

addResidual() [2/2]

void Assembly::addResidual

(

const std::map< TagName, TagID > &

tags

)

Definition at line 2319 of file Assembly.C.

{
  for (auto & tag : tags)
    if (_sys.hasVector(tag.second))
      addResidual(_sys.getVector(tag.second), tag.second);
}

addResidualBlock()

void Assembly::addResidualBlock ( NumericVector< Number > &  residual, DenseVector< Number > &  res_block, const std::vector< dof_id_type > &  dof_indices, Real  scaling_factor  )

protected

Definition at line 2250 of file Assembly.C.

Referenced by addResidual(), addResidualNeighbor(), and addResidualScalar().

{
  if (dof_indices.size() > 0 && res_block.size())
  {
    _temp_dof_indices = dof_indices;
    _dof_map.constrain_element_vector(res_block, _temp_dof_indices, false);

    if (scaling_factor != 1.0)
    {
      _tmp_Re = res_block;
      _tmp_Re *= scaling_factor;
      residual.add_vector(_tmp_Re, _temp_dof_indices);
    }
    else
    {
      residual.add_vector(res_block, _temp_dof_indices);
    }
  }
}

addResidualNeighbor() [1/2]

void Assembly::addResidualNeighbor	(	NumericVector< Number > &	residual,
		TagID	tag_id = 0
	)

Definition at line 2327 of file Assembly.C.

Referenced by addResidualNeighbor().

{
  const std::vector<MooseVariableFEBase *> & vars = _sys.getVariables(_tid);
  for (const auto & var : vars)
    addResidualBlock(
        residual, _sub_Rn[tag_id][var->number()], var->dofIndicesNeighbor(), var->scalingFactor());
}

addResidualNeighbor() [2/2]

void Assembly::addResidualNeighbor

(

const std::map< TagName, TagID > &

tags

)

Definition at line 2336 of file Assembly.C.

{
  for (auto & tag : tags)
    if (_sys.hasVector(tag.second))
      addResidualNeighbor(_sys.getVector(tag.second), tag.second);
}

addResidualScalar() [1/2]

void Assembly::addResidualScalar

(

TagID

tag_id

)

Definition at line 2344 of file Assembly.C.

Referenced by addResidualScalar().

{
  // add the scalar variables residuals
  const std::vector<MooseVariableScalar *> & vars = _sys.getScalarVariables(_tid);
  for (const auto & var : vars)
    if (_sys.hasVector(tag_id))
      addResidualBlock(_sys.getVector(tag_id),
                       _sub_Re[tag_id][var->number()],
                       var->dofIndices(),
                       var->scalingFactor());
}

addResidualScalar() [2/2]

void Assembly::addResidualScalar

(

const std::map< TagName, TagID > &

tags

)

Definition at line 2357 of file Assembly.C.

{
  for (auto & tag : tags)
    addResidualScalar(tag.second);
}

adGradPhi()

template<typename T , ComputeStage compute_stage>

const VariableTestGradientType<T, compute_stage>::type& Assembly::adGradPhi ( const MooseVariableFE< T > &  v ) const

inline

Definition at line 701 of file Assembly.h.

  {
    return gradPhi(v);
  }

adJxW() [1/3]

template<ComputeStage compute_stage>

const MooseArray<ADReal>& Assembly::adJxW ( ) const

inline

Definition at line 238 of file Assembly.h.

  {
    return _ad_JxW;
  }

adJxW() [2/3]

template<>

const MooseArray<typename Moose::RealType<RESIDUAL>::type>& Assembly::adJxW

(

)

const

adJxW() [3/3]

template<>

const MooseArray<typename Moose::RealType<RESIDUAL>::type>& Assembly::adJxW

(

)

const

Definition at line 3218 of file Assembly.C.

{
  return _current_JxW;
}

adJxWFace()

template<ComputeStage compute_stage>

const MooseArray<ADReal>& Assembly::adJxWFace ( ) const

inline

Definition at line 244 of file Assembly.h.

  {
    return _current_JxW_face;
  }

adNormals()

template<ComputeStage compute_stage>

const ADPoint& Assembly::adNormals ( ) const

inline

Definition at line 299 of file Assembly.h.

  {
    return _current_normals;
  }

adQPoints()

template<ComputeStage compute_stage>

const ADPoint& Assembly::adQPoints ( ) const

inline

Definition at line 305 of file Assembly.h.

  {
    return _current_q_points;
  }

adQPointsFace()

template<ComputeStage compute_stage>

const ADPoint& Assembly::adQPointsFace ( ) const

inline

Definition at line 311 of file Assembly.h.

  {
    return _current_q_points_face;
  }

assignDisplacements()

void Assembly::assignDisplacements ( std::vector< unsigned > &&  disp_numbers )

inline

Definition at line 1049 of file Assembly.h.

{ _displacements = disp_numbers; }

buildFaceFE()

void Assembly::buildFaceFE

(

FEType

type

)

Build FEs for a face with a type.

Parameters

type	The type of FE

Definition at line 241 of file Assembly.C.

Referenced by Assembly(), feCurlPhiFace(), feGradPhiFace(), fePhiFace(), feSecondPhiFace(), and getFEFace().

{
  if (!_fe_shape_data_face[type])
    _fe_shape_data_face[type] = new FEShapeData;

  // Build an FE object for this type for each dimension up to the dimension of the current mesh
  for (unsigned int dim = 0; dim <= _mesh_dimension; dim++)
  {
    if (!_fe_face[dim][type])
      _fe_face[dim][type] = FEGenericBase<Real>::build(dim, type).release();

    _fe_face[dim][type]->get_phi();
    _fe_face[dim][type]->get_dphi();
    if (_need_second_derivative.find(type) != _need_second_derivative.end())
      _fe_face[dim][type]->get_d2phi();
  }
}

buildFaceNeighborFE()

void Assembly::buildFaceNeighborFE

(

FEType

type

)

Build FEs for a neighbor face with a type.

Parameters

type	The type of FE

Definition at line 279 of file Assembly.C.

Referenced by Assembly(), feCurlPhiFaceNeighbor(), feGradPhiFaceNeighbor(), fePhiFaceNeighbor(), feSecondPhiFaceNeighbor(), and getFEFaceNeighbor().

{
  if (!_fe_shape_data_face_neighbor[type])
    _fe_shape_data_face_neighbor[type] = new FEShapeData;

  // Build an FE object for this type for each dimension up to the dimension of the current mesh
  for (unsigned int dim = 0; dim <= _mesh_dimension; dim++)
  {
    if (!_fe_face_neighbor[dim][type])
      _fe_face_neighbor[dim][type] = FEGenericBase<Real>::build(dim, type).release();

    _fe_face_neighbor[dim][type]->get_phi();
    _fe_face_neighbor[dim][type]->get_dphi();
    if (_need_second_derivative_neighbor.find(type) != _need_second_derivative_neighbor.end())
      _fe_face_neighbor[dim][type]->get_d2phi();
  }
}

buildFE()

void Assembly::buildFE

(

FEType

type

)

Build FEs with a type.

Parameters

type	The type of FE

Definition at line 218 of file Assembly.C.

Referenced by Assembly(), feCurlPhi(), feGradPhi(), fePhi(), feSecondPhi(), and getFE().

{
  if (!_fe_shape_data[type])
    _fe_shape_data[type] = new FEShapeData;

  // Build an FE object for this type for each dimension up to the dimension of the current mesh
  for (unsigned int dim = 0; dim <= _mesh_dimension; dim++)
  {
    if (!_fe[dim][type])
      _fe[dim][type] = FEGenericBase<Real>::build(dim, type).release();

    _fe[dim][type]->get_phi();
    _fe[dim][type]->get_dphi();
    // Pre-request xyz.  We have always computed xyz, but due to
    // recent optimizations in libmesh, we now need to explicity
    // request it, since apps (Yak) may rely on it being computed.
    _fe[dim][type]->get_xyz();
    if (_need_second_derivative.find(type) != _need_second_derivative.end())
      _fe[dim][type]->get_d2phi();
  }
}

buildNeighborFE()

void Assembly::buildNeighborFE

(

FEType

type

)

Build FEs for a neighbor with a type.

Parameters

type	The type of FE

Definition at line 260 of file Assembly.C.

Referenced by Assembly(), feCurlPhiNeighbor(), feGradPhiNeighbor(), fePhiNeighbor(), feSecondPhiNeighbor(), and getFENeighbor().

{
  if (!_fe_shape_data_neighbor[type])
    _fe_shape_data_neighbor[type] = new FEShapeData;

  // Build an FE object for this type for each dimension up to the dimension of the current mesh
  for (unsigned int dim = 0; dim <= _mesh_dimension; dim++)
  {
    if (!_fe_neighbor[dim][type])
      _fe_neighbor[dim][type] = FEGenericBase<Real>::build(dim, type).release();

    _fe_neighbor[dim][type]->get_phi();
    _fe_neighbor[dim][type]->get_dphi();
    if (_need_second_derivative_neighbor.find(type) != _need_second_derivative_neighbor.end())
      _fe_neighbor[dim][type]->get_d2phi();
  }
}

buildVectorFaceFE()

void Assembly::buildVectorFaceFE

(

FEType

type

)

Build Vector FEs for a face with a type.

Parameters

type	The type of FE

Definition at line 329 of file Assembly.C.

Referenced by getVectorFEFace().

{
  if (!_vector_fe_shape_data_face[type])
    _vector_fe_shape_data_face[type] = new VectorFEShapeData;

  unsigned int min_dim;
  if (type.family == LAGRANGE_VEC)
    min_dim = 0;
  else
    min_dim = 2;

  // Build an VectorFE object for this type for each dimension up to the dimension of the current
  // mesh
  // Note that NEDELEC_ONE elements can only be built for dimension > 2. The for loop logic should
  // be modified for LAGRANGE_VEC
  for (unsigned int dim = min_dim; dim <= _mesh_dimension; dim++)
  {
    if (!_vector_fe_face[dim][type])
      _vector_fe_face[dim][type] = FEGenericBase<VectorValue<Real>>::build(dim, type).release();

    _vector_fe_face[dim][type]->get_phi();
    _vector_fe_face[dim][type]->get_dphi();
    if (type.family == NEDELEC_ONE)
      _vector_fe_face[dim][type]->get_curl_phi();
  }
}

buildVectorFaceNeighborFE()

void Assembly::buildVectorFaceNeighborFE

(

FEType

type

)

Build Vector FEs for a neighbor face with a type.

Parameters

type	The type of FE

Definition at line 385 of file Assembly.C.

Referenced by getVectorFEFaceNeighbor().

{
  if (!_vector_fe_shape_data_face_neighbor[type])
    _vector_fe_shape_data_face_neighbor[type] = new VectorFEShapeData;

  unsigned int min_dim;
  if (type.family == LAGRANGE_VEC)
    min_dim = 0;
  else
    min_dim = 2;

  // Build an VectorFE object for this type for each dimension up to the dimension of the current
  // mesh
  // Note that NEDELEC_ONE elements can only be built for dimension > 2. The for loop logic should
  // be modified for LAGRANGE_VEC
  for (unsigned int dim = min_dim; dim <= _mesh_dimension; dim++)
  {
    if (!_vector_fe_face_neighbor[dim][type])
      _vector_fe_face_neighbor[dim][type] =
          FEGenericBase<VectorValue<Real>>::build(dim, type).release();

    _vector_fe_face_neighbor[dim][type]->get_phi();
    _vector_fe_face_neighbor[dim][type]->get_dphi();
    if (type.family == NEDELEC_ONE)
      _vector_fe_face_neighbor[dim][type]->get_curl_phi();
  }
}

buildVectorFE()

void Assembly::buildVectorFE

(

FEType

type

)

Build Vector FEs with a type.

Parameters

type	The type of FE

Definition at line 298 of file Assembly.C.

Referenced by getVectorFE().

{
  if (!_vector_fe_shape_data[type])
    _vector_fe_shape_data[type] = new VectorFEShapeData;

  unsigned int min_dim;
  if (type.family == LAGRANGE_VEC)
    min_dim = 0;
  else
    min_dim = 2;

  // Build an FE object for this type for each dimension up to the dimension of the current mesh
  // Note that NEDELEC_ONE elements can only be built for dimension > 2. The for loop logic should
  // be modified for LAGRANGE_VEC
  for (unsigned int dim = min_dim; dim <= _mesh_dimension; dim++)
  {
    if (!_vector_fe[dim][type])
      _vector_fe[dim][type] = FEGenericBase<VectorValue<Real>>::build(dim, type).release();

    _vector_fe[dim][type]->get_phi();
    _vector_fe[dim][type]->get_dphi();
    if (type.family == NEDELEC_ONE)
      _vector_fe[dim][type]->get_curl_phi();
    // Pre-request xyz.  We have always computed xyz, but due to
    // recent optimizations in libmesh, we now need to explicity
    // request it, since apps (Yak) may rely on it being computed.
    _vector_fe[dim][type]->get_xyz();
  }
}

buildVectorNeighborFE()

void Assembly::buildVectorNeighborFE

(

FEType

type

)

Build Vector FEs for a neighbor with a type.

Parameters

type	The type of FE

Definition at line 357 of file Assembly.C.

Referenced by getVectorFENeighbor().

{
  if (!_vector_fe_shape_data_neighbor[type])
    _vector_fe_shape_data_neighbor[type] = new VectorFEShapeData;

  unsigned int min_dim;
  if (type.family == LAGRANGE_VEC)
    min_dim = 0;
  else
    min_dim = 2;

  // Build an VectorFE object for this type for each dimension up to the dimension of the current
  // mesh
  // Note that NEDELEC_ONE elements can only be built for dimension > 2. The for loop logic should
  // be modified for LAGRANGE_VEC
  for (unsigned int dim = min_dim; dim <= _mesh_dimension; dim++)
  {
    if (!_vector_fe_neighbor[dim][type])
      _vector_fe_neighbor[dim][type] = FEGenericBase<VectorValue<Real>>::build(dim, type).release();

    _vector_fe_neighbor[dim][type]->get_phi();
    _vector_fe_neighbor[dim][type]->get_dphi();
    if (type.family == NEDELEC_ONE)
      _vector_fe_neighbor[dim][type]->get_curl_phi();
  }
}

cacheJacobian()

void Assembly::cacheJacobian

(

)

Takes the values that are currently in _sub_Kee and appends them to the cached values.

Definition at line 2744 of file Assembly.C.

{
  for (const auto & it : _cm_ff_entry)
    cacheJacobianCoupledVarPair(it.first, it.second);

  for (const auto & it : _cm_fs_entry)
    cacheJacobianCoupledVarPair(it.first, it.second);

  for (const auto & it : _cm_sf_entry)
    cacheJacobianCoupledVarPair(it.first, it.second);
}

cacheJacobianBlock()

void Assembly::cacheJacobianBlock	(	DenseMatrix< Number > &	jac_block,
		std::vector< dof_id_type > &	idof_indices,
		std::vector< dof_id_type > &	jdof_indices,
		Real	scaling_factor,
		TagID	tag = 0
	)

Definition at line 2540 of file Assembly.C.

Referenced by cacheJacobianCoupledVarPair(), cacheJacobianNeighbor(), NodalConstraint::computeJacobian(), and NonlinearSystemBase::constraintJacobians().

{
  // Only cache data when the matrix exists
  if ((idof_indices.size() > 0) && (jdof_indices.size() > 0) && jac_block.n() && jac_block.m() &&
      _sys.hasMatrix(tag))
  {
    std::vector<dof_id_type> di(idof_indices);
    std::vector<dof_id_type> dj(jdof_indices);
    _dof_map.constrain_element_matrix(jac_block, di, dj, false);

    if (scaling_factor != 1.0)
      jac_block *= scaling_factor;

    for (MooseIndex(di) i = 0; i < di.size(); i++)
      for (MooseIndex(dj) j = 0; j < dj.size(); j++)
      {
        _cached_jacobian_values[tag].push_back(jac_block(i, j));
        _cached_jacobian_rows[tag].push_back(di[i]);
        _cached_jacobian_cols[tag].push_back(dj[j]);
      }
  }
  jac_block.zero();
}

cacheJacobianBlockNonlocal()

void Assembly::cacheJacobianBlockNonlocal	(	DenseMatrix< Number > &	jac_block,
		const std::vector< dof_id_type > &	idof_indices,
		const std::vector< dof_id_type > &	jdof_indices,
		Real	scaling_factor,
		TagID	tag = 0
	)

Definition at line 2569 of file Assembly.C.

Referenced by cacheJacobianNonlocal().

{
  if ((idof_indices.size() > 0) && (jdof_indices.size() > 0) && jac_block.n() && jac_block.m() &&
      _sys.hasMatrix(tag))
  {
    std::vector<dof_id_type> di(idof_indices);
    std::vector<dof_id_type> dj(jdof_indices);
    _dof_map.constrain_element_matrix(jac_block, di, dj, false);

    if (scaling_factor != 1.0)
      jac_block *= scaling_factor;

    for (MooseIndex(di) i = 0; i < di.size(); i++)
      for (MooseIndex(dj) j = 0; j < dj.size(); j++)
        if (jac_block(i, j) != 0.0) // no storage allocated for unimplemented jacobian terms,
                                    // maintaining maximum sparsity possible
        {
          _cached_jacobian_values[tag].push_back(jac_block(i, j));
          _cached_jacobian_rows[tag].push_back(di[i]);
          _cached_jacobian_cols[tag].push_back(dj[j]);
        }
  }
  jac_block.zero();
}

cacheJacobianContribution() [1/2]

void Assembly::cacheJacobianContribution	(	numeric_index_type	i,
		numeric_index_type	j,
		Real	value,
		TagID	tag = 0
	)

Caches the Jacobian entry 'value', to eventually be added/set in the (i,j) location of the matrix.

We use numeric_index_type for the index arrays (rather than dof_id_type) since that is what the SparseMatrix interface uses, but at the time of this writing, those two types are equivalent.

Definition at line 2921 of file Assembly.C.

Referenced by cacheJacobianContribution(), VectorNodalBC::computeJacobian(), NodalBC::computeJacobian(), NodalKernel::computeJacobian(), VectorNodalBC::computeOffDiagJacobian(), NodalBC::computeOffDiagJacobian(), and NodalKernel::computeOffDiagJacobian().

{
  _cached_jacobian_contribution_rows[tag].push_back(i);
  _cached_jacobian_contribution_cols[tag].push_back(j);
  _cached_jacobian_contribution_vals[tag].push_back(value);
}

cacheJacobianContribution() [2/2]

void Assembly::cacheJacobianContribution	(	numeric_index_type	i,
		numeric_index_type	j,
		Real	value,
		const std::set< TagID > &	tags
	)

Definition at line 2932 of file Assembly.C.

{
  for (auto tag : tags)
    if (_sys.hasMatrix(tag))
      cacheJacobianContribution(i, j, value, tag);
}

cacheJacobianCoupledVarPair()

void Assembly::cacheJacobianCoupledVarPair ( MooseVariableBase *  ivar, MooseVariableBase *  jvar  )

inline

Caches element matrix for ivar rows and jvar columns.

Definition at line 2730 of file Assembly.C.

Referenced by cacheJacobian().

{
  auto i = ivar->number();
  auto j = jvar->number();
  for (MooseIndex(_jacobian_block_used) tag = 0; tag < _jacobian_block_used.size(); tag++)
    if (_jacobian_block_used[tag][i][j] && _sys.hasMatrix(tag))
      cacheJacobianBlock(jacobianBlock(i, j, tag),
                         ivar->dofIndices(),
                         jvar->dofIndices(),
                         ivar->scalingFactor(),
                         tag);
}

cacheJacobianNeighbor()

void Assembly::cacheJacobianNeighbor

(

)

Takes the values that are currently in the neighbor Dense Matrices and appends them to the cached values.

Definition at line 2778 of file Assembly.C.

{
  for (const auto & it : _cm_ff_entry)
  {
    auto ivar = it.first;
    auto jvar = it.second;
    auto i = ivar->number();
    auto j = jvar->number();

    for (MooseIndex(_jacobian_block_neighbor_used) tag = 0;
         tag < _jacobian_block_neighbor_used.size();
         tag++)
      if (_jacobian_block_neighbor_used[tag][i][j] && _sys.hasMatrix(tag))
      {
        cacheJacobianBlock(jacobianBlockNeighbor(Moose::ElementNeighbor, i, j, tag),
                           ivar->dofIndices(),
                           jvar->dofIndicesNeighbor(),
                           ivar->scalingFactor(),
                           tag);
        cacheJacobianBlock(jacobianBlockNeighbor(Moose::NeighborElement, i, j, tag),
                           ivar->dofIndicesNeighbor(),
                           jvar->dofIndices(),
                           ivar->scalingFactor(),
                           tag);
        cacheJacobianBlock(jacobianBlockNeighbor(Moose::NeighborNeighbor, i, j, tag),
                           ivar->dofIndicesNeighbor(),
                           jvar->dofIndicesNeighbor(),
                           ivar->scalingFactor(),
                           tag);
      }
  }
}

cacheJacobianNonlocal()

void Assembly::cacheJacobianNonlocal

(

)

Takes the values that are currently in _sub_Keg and appends them to the cached values.

Definition at line 2757 of file Assembly.C.

{
  for (const auto & it : _cm_nonlocal_entry)
  {
    auto ivar = it.first;
    auto jvar = it.second;
    auto i = ivar->number();
    auto j = jvar->number();
    for (MooseIndex(_jacobian_block_nonlocal_used) tag = 0;
         tag < _jacobian_block_nonlocal_used.size();
         tag++)
      if (_jacobian_block_nonlocal_used[tag][i][j] && _sys.hasMatrix(tag))
        cacheJacobianBlockNonlocal(jacobianBlockNonlocal(i, j, tag),
                                   ivar->dofIndices(),
                                   jvar->allDofIndices(),
                                   ivar->scalingFactor(),
                                   tag);
  }
}

cacheResidual()

void Assembly::cacheResidual

(

)

Takes the values that are currently in _sub_Re and appends them to the cached values.

Definition at line 2364 of file Assembly.C.

{
  const std::vector<MooseVariableFEBase *> & vars = _sys.getVariables(_tid);
  for (const auto & var : vars)
  {
    for (MooseIndex(_cached_residual_values) tag = 0; tag < _cached_residual_values.size(); tag++)
      if (_sys.hasVector(tag))
        cacheResidualBlock(_cached_residual_values[tag],
                           _cached_residual_rows[tag],
                           _sub_Re[tag][var->number()],
                           var->dofIndices(),
                           var->scalingFactor());
  }
}

cacheResidualBlock()

void Assembly::cacheResidualBlock ( std::vector< Real > &  cached_residual_values, std::vector< dof_id_type > &  cached_residual_rows, DenseVector< Number > &  res_block, std::vector< dof_id_type > &  dof_indices, Real  scaling_factor  )

protected

Definition at line 2274 of file Assembly.C.

Referenced by cacheResidual(), and cacheResidualNeighbor().

{
  if (dof_indices.size() > 0 && res_block.size())
  {
    _temp_dof_indices = dof_indices;
    _dof_map.constrain_element_vector(res_block, _temp_dof_indices, false);

    if (scaling_factor != 1.0)
    {
      _tmp_Re = res_block;
      _tmp_Re *= scaling_factor;

      for (MooseIndex(_tmp_Re) i = 0; i < _tmp_Re.size(); i++)
      {
        cached_residual_values.push_back(_tmp_Re(i));
        cached_residual_rows.push_back(_temp_dof_indices[i]);
      }
    }
    else
    {
      for (MooseIndex(res_block) i = 0; i < res_block.size(); i++)
      {
        cached_residual_values.push_back(res_block(i));
        cached_residual_rows.push_back(_temp_dof_indices[i]);
      }
    }
  }

  res_block.zero();
}

cacheResidualContribution() [1/2]

void Assembly::cacheResidualContribution	(	dof_id_type	dof,
		Real	value,
		TagID	tag_id
	)

Cache individual residual contributions.

These will ultimately get added to the residual when addCachedResidual() is called.

Parameters

dof	The degree of freedom to add the residual contribution to
value	The value of the residual contribution.
TagID	the contribution should go to the tagged residual

Definition at line 2380 of file Assembly.C.

Referenced by cacheResidualContribution(), TimeNodalKernel::computeResidual(), and NodalKernel::computeResidual().

{
  _cached_residual_values[tag_id].push_back(value);
  _cached_residual_rows[tag_id].push_back(dof);
}

cacheResidualContribution() [2/2]

void Assembly::cacheResidualContribution	(	dof_id_type	dof,
		Real	value,
		const std::set< TagID > &	tags
	)

Cache individual residual contributions.

These will ultimately get added to the residual when addCachedResidual() is called.

Parameters

dof	The degree of freedom to add the residual contribution to
value	The value of the residual contribution.
tags	the contribution should go to all tags

Definition at line 2387 of file Assembly.C.

{
  for (auto & tag : tags)
    cacheResidualContribution(dof, value, tag);
}

cacheResidualNeighbor()

void Assembly::cacheResidualNeighbor

(

)

Takes the values that are currently in _sub_Ke and appends them to the cached values.

Definition at line 2394 of file Assembly.C.

{
  const std::vector<MooseVariableFEBase *> & vars = _sys.getVariables(_tid);
  for (const auto & var : vars)
  {
    for (MooseIndex(_cached_residual_values) tag = 0; tag < _cached_residual_values.size(); tag++)
    {
      if (_sys.hasVector(tag))
        cacheResidualBlock(_cached_residual_values[tag],
                           _cached_residual_rows[tag],
                           _sub_Rn[tag][var->number()],
                           var->dofIndicesNeighbor(),
                           var->scalingFactor());
    }
  }
}

cacheResidualNodes()

void Assembly::cacheResidualNodes	(	const DenseVector< Number > &	res,
		std::vector< dof_id_type > &	dof_index,
		TagID	tag = 0
	)

Lets an external class cache residual at a set of nodes.

Definition at line 2412 of file Assembly.C.

Referenced by NodalConstraint::computeResidual().

{
  // Add the residual value and dof_index to cached_residual_values and cached_residual_rows
  // respectively.
  // This is used by NodalConstraint.C to cache the residual calculated for master and slave node.
  for (MooseIndex(dof_index) i = 0; i < dof_index.size(); ++i)
  {
    _cached_residual_values[tag].push_back(res(i));
    _cached_residual_rows[tag].push_back(dof_index[i]);
  }
}

clearCachedJacobianContributions()

void Assembly::clearCachedJacobianContributions ( )

protected

Clear any currently cached jacobian contributions.

This is automatically called by setCachedJacobianContributions and addCachedJacobianContributions

Definition at line 2999 of file Assembly.C.

Referenced by addCachedJacobianContributions(), setCachedJacobianContributions(), and zeroCachedJacobianContributions().

{
  for (MooseIndex(_cached_jacobian_contribution_rows) tag = 0;
       tag < _cached_jacobian_contribution_rows.size();
       tag++)
  {
    auto orig_size = _cached_jacobian_contribution_rows[tag].size();

    _cached_jacobian_contribution_rows[tag].clear();
    _cached_jacobian_contribution_cols[tag].clear();
    _cached_jacobian_contribution_vals[tag].clear();

    // It's possible (though massively unlikely) that clear() will
    // change the capacity of the vectors, so let's be paranoid and
    // explicitly reserve() the same amount of memory to avoid multiple
    // push_back() induced allocations.  We reserve 20% more than the
    // original size that was cached to account for variations in the
    // number of BCs assigned to each thread (for when the Jacobian
    // contributions are computed threaded).
    _cached_jacobian_contribution_rows[tag].reserve(1.2 * orig_size);
    _cached_jacobian_contribution_cols[tag].reserve(1.2 * orig_size);
    _cached_jacobian_contribution_vals[tag].reserve(1.2 * orig_size);
  }
}

computeAffineMapAD()

void Assembly::computeAffineMapAD ( const Elem *  elem, const std::vector< Real > &  qw, unsigned int  n_qp, FEBase *  fe  )

protected

Definition at line 699 of file Assembly.C.

Referenced by reinitFE(), and reinitFEFace().

{
  computeSinglePointMapAD(elem, qw, 0, fe);

  for (unsigned int p = 1; p < n_qp; p++)
  {
    // Compute xyz at all other quadrature points. Note that this map method call is only really
    // referring to the volumetric element...face quadrature points are calculated in computeFaceMap
    if (_calculate_xyz)
    {
      auto num_shapes = fe->n_shape_functions();
      const auto & elem_nodes = elem->get_nodes();
      const auto & phi_map = fe->get_fe_map().get_phi_map();
      _ad_q_points[p].zero();
      for (decltype(num_shapes) i = 0; i < num_shapes; ++i)
      {
        mooseAssert(elem_nodes[i], "The node is null!");
        VectorValue<DualReal> elem_point = *elem_nodes[i];
        unsigned dimension = 0;
        for (const auto & disp_num : _displacements)
          elem_point(dimension++).derivatives()[disp_num * _sys.getMaxVarNDofsPerElem() + i] = 1.;

        _ad_q_points[p].add_scaled(elem_point, phi_map[i][p]);
      }
    }

    // Now copy over other map data for each extra quadrature point

    _ad_dxyzdxi_map[p] = _ad_dxyzdxi_map[0];
    _ad_dxidx_map[p] = _ad_dxidx_map[0];
    _ad_dxidy_map[p] = _ad_dxidy_map[0];
    _ad_dxidz_map[p] = _ad_dxidz_map[0];

    if (elem->dim() > 1)
    {
      _ad_dxyzdeta_map[p] = _ad_dxyzdeta_map[0];
      _ad_detadx_map[p] = _ad_detadx_map[0];
      _ad_detady_map[p] = _ad_detady_map[0];
      _ad_detadz_map[p] = _ad_detadz_map[0];

      if (elem->dim() > 2)
      {
        _ad_dxyzdzeta_map[p] = _ad_dxyzdzeta_map[0];
        _ad_dzetadx_map[p] = _ad_dzetadx_map[0];
        _ad_dzetady_map[p] = _ad_dzetady_map[0];
        _ad_dzetadz_map[p] = _ad_dzetadz_map[0];
      }
    }
    _ad_jac[p] = _ad_jac[0];
    _ad_JxW[p] = _ad_JxW[0] / qw[0] * qw[p];
  }
}

computeCurrentElemVolume()

void Assembly::computeCurrentElemVolume ( )

protected

Definition at line 1535 of file Assembly.C.

Referenced by reinit().

{
  if (_current_elem_volume_computed)
    return;

  setCoordinateTransformation<ComputeStage::RESIDUAL>(_current_qrule, _current_q_points, _coord);
  if (_computing_jacobian && _calculate_xyz)
    setCoordinateTransformation<ComputeStage::JACOBIAN>(_current_qrule, _ad_q_points, _ad_coord);

  _current_elem_volume = 0.;
  for (unsigned int qp = 0; qp < _current_qrule->n_points(); qp++)
    _current_elem_volume += _current_JxW[qp] * _coord[qp];

  _current_elem_volume_computed = true;
}

computeCurrentFaceVolume()

void Assembly::computeCurrentFaceVolume ( )

protected

Definition at line 1552 of file Assembly.C.

Referenced by reinit().

{
  if (_current_side_volume_computed)
    return;

  setCoordinateTransformation<ComputeStage::RESIDUAL>(
      _current_qrule_face, _current_q_points_face, _coord);
  if (_computing_jacobian && _calculate_face_xyz)
    setCoordinateTransformation<ComputeStage::JACOBIAN>(
        _current_qrule_face, _ad_q_points_face, _ad_coord);

  _current_side_volume = 0.;
  for (unsigned int qp = 0; qp < _current_qrule_face->n_points(); qp++)
    _current_side_volume += _current_JxW_face[qp] * _coord[qp];

  _current_side_volume_computed = true;
}

computeCurrentNeighborVolume()

void Assembly::computeCurrentNeighborVolume ( )

protected

computeFaceMap()

void Assembly::computeFaceMap ( unsigned  dim, const std::vector< Real > &  qw, const Elem *  side  )

protected

Definition at line 1110 of file Assembly.C.

Referenced by reinitFEFace().

{
  const auto n_qp = qw.size();
  const Elem * elem = side->parent();
  auto side_number = elem->which_side_am_i(side);
  const auto & dpsidxi_map = (*_holder_fe_face_helper[dim])->get_fe_map().get_dpsidxi();
  const auto & dpsideta_map = (*_holder_fe_face_helper[dim])->get_fe_map().get_dpsideta();
  const auto & psi_map = (*_holder_fe_face_helper[dim])->get_fe_map().get_psi();
  std::vector<std::vector<Real>> const * d2psidxi2_map = nullptr;
  std::vector<std::vector<Real>> const * d2psidxideta_map = nullptr;
  std::vector<std::vector<Real>> const * d2psideta2_map = nullptr;
  if (_calculate_curvatures)
  {
    d2psidxi2_map = &(*_holder_fe_face_helper[dim])->get_fe_map().get_d2psidxi2();
    d2psidxideta_map = &(*_holder_fe_face_helper[dim])->get_fe_map().get_d2psidxideta();
    d2psideta2_map = &(*_holder_fe_face_helper[dim])->get_fe_map().get_d2psideta2();
  }

  switch (dim)
  {
    case 1:
    {
      if (!n_qp)
        break;

      if (side->node_id(0) == elem->node_id(0))
        _ad_normals[0] = Point(-1.);
      else
        _ad_normals[0] = Point(1.);

      VectorValue<DualReal> side_point;
      if (_calculate_face_xyz)
      {
        side_point = side->point(0);
        auto element_node_number = elem->which_node_am_i(side_number, 0);

        unsigned dimension = 0;
        for (const auto & disp_num : _displacements)
          side_point(dimension++)
              .derivatives()[disp_num * _sys.getMaxVarNDofsPerElem() + element_node_number] = 1.;
      }

      for (unsigned int p = 0; p < n_qp; p++)
      {
        if (_calculate_face_xyz)
        {
          _ad_q_points_face[p].zero();
          _ad_q_points_face[p].add_scaled(side_point, psi_map[0][p]);
        }

        _ad_normals[p] = _ad_normals[0];
        _ad_JxW_face[p] = 1.0 * qw[p];
      }

      break;
    }

    case 2:
    {
      _ad_dxyzdxi_map.resize(n_qp);
      if (_calculate_curvatures)
        _ad_d2xyzdxi2_map.resize(n_qp);

      for (unsigned int p = 0; p < n_qp; p++)
      {
        _ad_dxyzdxi_map[p].zero();
        if (_calculate_face_xyz)
          _ad_q_points_face[p].zero();
        if (_calculate_curvatures)
          _ad_d2xyzdxi2_map[p].zero();
      }

      const auto n_mapping_shape_functions =
          FE<2, LAGRANGE>::n_shape_functions(side->type(), side->default_order());

      for (unsigned int i = 0; i < n_mapping_shape_functions; i++)
      {
        VectorValue<DualReal> side_point = side->point(i);
        auto element_node_number = elem->which_node_am_i(side_number, i);

        unsigned dimension = 0;
        for (const auto & disp_num : _displacements)
          side_point(dimension++)
              .derivatives()[disp_num * _sys.getMaxVarNDofsPerElem() + element_node_number] = 1.;

        for (unsigned int p = 0; p < n_qp; p++)
        {
          _ad_dxyzdxi_map[p].add_scaled(side_point, dpsidxi_map[i][p]);
          if (_calculate_face_xyz)
            _ad_q_points_face[p].add_scaled(side_point, psi_map[i][p]);
          if (_calculate_curvatures)
            _ad_d2xyzdxi2_map[p].add_scaled(side_point, (*d2psidxi2_map)[i][p]);
        }
      }

      for (unsigned int p = 0; p < n_qp; p++)
      {
        _ad_normals[p] =
            (VectorValue<DualReal>(_ad_dxyzdxi_map[p](1), -_ad_dxyzdxi_map[p](0), 0.)).unit();
        const auto the_jac = _ad_dxyzdxi_map[p].norm();
        _ad_JxW_face[p] = the_jac * qw[p];
        if (_calculate_curvatures)
        {
          const auto numerator = _ad_d2xyzdxi2_map[p] * _ad_normals[p];
          const auto denominator = _ad_dxyzdxi_map[p].norm_sq();
          libmesh_assert_not_equal_to(denominator, 0);
          _ad_curvatures[p] = numerator / denominator;
        }
      }

      break;
    }

    case 3:
    {
      _ad_dxyzdxi_map.resize(n_qp);
      _ad_dxyzdeta_map.resize(n_qp);
      if (_calculate_curvatures)
      {
        _ad_d2xyzdxi2_map.resize(n_qp);
        _ad_d2xyzdxideta_map.resize(n_qp);
        _ad_d2xyzdeta2_map.resize(n_qp);
      }

      for (unsigned int p = 0; p < n_qp; p++)
      {
        _ad_dxyzdxi_map[p].zero();
        _ad_dxyzdeta_map[p].zero();
        if (_calculate_face_xyz)
          _ad_q_points_face[p].zero();
        if (_calculate_curvatures)
        {
          _ad_d2xyzdxi2_map[p].zero();
          _ad_d2xyzdxideta_map[p].zero();
          _ad_d2xyzdeta2_map[p].zero();
        }
      }

      const unsigned int n_mapping_shape_functions =
          FE<3, LAGRANGE>::n_shape_functions(side->type(), side->default_order());

      for (unsigned int i = 0; i < n_mapping_shape_functions; i++)
      {
        VectorValue<DualReal> side_point = side->point(i);
        auto element_node_number = elem->which_node_am_i(side_number, i);

        unsigned dimension = 0;
        for (const auto & disp_num : _displacements)
          side_point(dimension++)
              .derivatives()[disp_num * _sys.getMaxVarNDofsPerElem() + element_node_number] = 1.;

        for (unsigned int p = 0; p < n_qp; p++)
        {
          _ad_dxyzdxi_map[p].add_scaled(side_point, dpsidxi_map[i][p]);
          _ad_dxyzdeta_map[p].add_scaled(side_point, dpsideta_map[i][p]);
          if (_calculate_face_xyz)
            _ad_q_points_face[p].add_scaled(side_point, psi_map[i][p]);
          if (_calculate_curvatures)
          {
            _ad_d2xyzdxi2_map[p].add_scaled(side_point, (*d2psidxi2_map)[i][p]);
            _ad_d2xyzdxideta_map[p].add_scaled(side_point, (*d2psidxideta_map)[i][p]);
            _ad_d2xyzdeta2_map[p].add_scaled(side_point, (*d2psideta2_map)[i][p]);
          }
        }
      }

      for (unsigned int p = 0; p < n_qp; p++)
      {
        _ad_normals[p] = _ad_dxyzdxi_map[p].cross(_ad_dxyzdeta_map[p]).unit();

        const auto &dxdxi = _ad_dxyzdxi_map[p](0), dxdeta = _ad_dxyzdeta_map[p](0),
                   dydxi = _ad_dxyzdxi_map[p](1), dydeta = _ad_dxyzdeta_map[p](1),
                   dzdxi = _ad_dxyzdxi_map[p](2), dzdeta = _ad_dxyzdeta_map[p](2);

        const auto g11 = (dxdxi * dxdxi + dydxi * dydxi + dzdxi * dzdxi);

        const auto g12 = (dxdxi * dxdeta + dydxi * dydeta + dzdxi * dzdeta);

        const auto g21 = g12;

        const auto g22 = (dxdeta * dxdeta + dydeta * dydeta + dzdeta * dzdeta);

        const auto the_jac = std::sqrt(g11 * g22 - g12 * g21);

        _ad_JxW_face[p] = the_jac * qw[p];

        if (_calculate_curvatures)
        {
          const auto L = -_ad_d2xyzdxi2_map[p] * _ad_normals[p];
          const auto M = -_ad_d2xyzdxideta_map[p] * _ad_normals[p];
          const auto N = -_ad_d2xyzdeta2_map[p] * _ad_normals[p];
          const auto E = _ad_dxyzdxi_map[p].norm_sq();
          const auto F = _ad_dxyzdxi_map[p] * _ad_dxyzdeta_map[p];
          const auto G = _ad_dxyzdeta_map[p].norm_sq();

          const auto numerator = E * N - 2. * F * M + G * L;
          const auto denominator = E * G - F * F;
          libmesh_assert_not_equal_to(denominator, 0.);
          _ad_curvatures[p] = 0.5 * numerator / denominator;
        }
      }

      break;
    }

    default:
      mooseError("Invalid dimension dim = ", dim);
  }
}

computeGradPhiAD() [1/2]

template<typename OutputType >

void Assembly::computeGradPhiAD ( const Elem *  elem, unsigned int  n_qp, typename VariableTestGradientType< OutputType, ComputeStage::JACOBIAN >::type &  grad_phi, FEGenericBase< OutputType > *  fe  )

protected

Definition at line 602 of file Assembly.C.

Referenced by reinitFE(), and reinitFEFace().

{
  auto dim = elem->dim();
  const auto & dphidxi = fe->get_dphidxi();
  const auto & dphideta = fe->get_dphideta();
  const auto & dphidzeta = fe->get_dphidzeta();
  auto num_shapes = grad_phi.size();

  switch (dim)
  {
    case 0:
    {
      for (decltype(num_shapes) i = 0; i < num_shapes; ++i)
        for (unsigned qp = 0; qp < n_qp; ++qp)
          grad_phi[i][qp] = 0;
      break;
    }

    case 1:
    {
      for (decltype(num_shapes) i = 0; i < num_shapes; ++i)
        for (unsigned qp = 0; qp < n_qp; ++qp)
        {
          grad_phi[i][qp](0) = dphidxi[i][qp] * _ad_dxidx_map[qp];
          grad_phi[i][qp](1) = dphidxi[i][qp] * _ad_dxidy_map[qp];
          grad_phi[i][qp](2) = dphidxi[i][qp] * _ad_dxidz_map[qp];
        }
      break;
    }

    case 2:
    {
      for (decltype(num_shapes) i = 0; i < num_shapes; ++i)
        for (unsigned qp = 0; qp < n_qp; ++qp)
        {
          grad_phi[i][qp](0) =
              dphidxi[i][qp] * _ad_dxidx_map[qp] + dphideta[i][qp] * _ad_detadx_map[qp];
          grad_phi[i][qp](1) =
              dphidxi[i][qp] * _ad_dxidy_map[qp] + dphideta[i][qp] * _ad_detady_map[qp];
          grad_phi[i][qp](2) =
              dphidxi[i][qp] * _ad_dxidz_map[qp] + dphideta[i][qp] * _ad_detadz_map[qp];
        }
      break;
    }

    case 3:
    {
      for (decltype(num_shapes) i = 0; i < num_shapes; ++i)
        for (unsigned qp = 0; qp < n_qp; ++qp)
        {
          grad_phi[i][qp](0) = dphidxi[i][qp] * _ad_dxidx_map[qp] +
                               dphideta[i][qp] * _ad_detadx_map[qp] +
                               dphidzeta[i][qp] * _ad_dzetadx_map[qp];
          grad_phi[i][qp](1) = dphidxi[i][qp] * _ad_dxidy_map[qp] +
                               dphideta[i][qp] * _ad_detady_map[qp] +
                               dphidzeta[i][qp] * _ad_dzetady_map[qp];
          grad_phi[i][qp](2) = dphidxi[i][qp] * _ad_dxidz_map[qp] +
                               dphideta[i][qp] * _ad_detadz_map[qp] +
                               dphidzeta[i][qp] * _ad_dzetadz_map[qp];
        }
      break;
    }
  }
}

computeGradPhiAD() [2/2]

template<>

void Assembly::computeGradPhiAD ( const Elem *  , unsigned int  , typename VariableTestGradientType< RealVectorValue, ComputeStage::JACOBIAN >::type &  , FEGenericBase< RealVectorValue > *    )

inlineprotected

Definition at line 1502 of file Assembly.h.

{
  mooseError("Not implemented");
}

computeSinglePointMapAD()

void Assembly::computeSinglePointMapAD ( const Elem *  elem, const std::vector< Real > &  qw, unsigned  p, FEBase *  fe  )

protected

Definition at line 756 of file Assembly.C.

Referenced by computeAffineMapAD(), reinitFE(), and reinitFEFace().

{
  auto dim = elem->dim();
  const auto & elem_nodes = elem->get_nodes();
  auto num_shapes = fe->n_shape_functions();
  const auto & phi_map = fe->get_fe_map().get_phi_map();
  const auto & dphidxi_map = fe->get_fe_map().get_dphidxi_map();
  const auto & dphideta_map = fe->get_fe_map().get_dphideta_map();
  const auto & dphidzeta_map = fe->get_fe_map().get_dphidzeta_map();

  switch (dim)
  {
    case 0:
    {
      _ad_jac[p] = 1.0;
      _ad_JxW[p] = qw[p];
      if (_calculate_xyz)
        _ad_q_points[p] = *elem_nodes[0];
      break;
    }

    case 1:
    {
      if (_calculate_xyz)
        _ad_q_points[p].zero();

      _ad_dxyzdxi_map[p].zero();

      for (std::size_t i = 0; i < num_shapes; i++)
      {
        libmesh_assert(elem_nodes[i]);
        libMesh::VectorValue<DualReal> elem_point = *elem_nodes[i];
        unsigned dimension = 0;
        for (const auto & disp_num : _displacements)
          elem_point(dimension++).derivatives()[disp_num * _sys.getMaxVarNDofsPerElem() + i] = 1.;

        _ad_dxyzdxi_map[p].add_scaled(elem_point, dphidxi_map[i][p]);

        if (_calculate_xyz)
          _ad_q_points[p].add_scaled(elem_point, phi_map[i][p]);
      }

      _ad_jac[p] = _ad_dxyzdxi_map[p].norm();

      if (_ad_jac[p].value() <= -TOLERANCE * TOLERANCE)
      {
        static bool failing = false;
        if (!failing)
        {
          failing = true;
          elem->print_info(libMesh::err);
          libmesh_error_msg("ERROR: negative Jacobian " << _ad_jac[p].value() << " at point index "
                                                        << p << " in element " << elem->id());
        }
        else
          return;
      }

      const auto jacm2 = 1. / _ad_jac[p] / _ad_jac[p];
      _ad_dxidx_map[p] = jacm2 * _ad_dxyzdxi_map[p](0);
      _ad_dxidy_map[p] = jacm2 * _ad_dxyzdxi_map[p](1);
      _ad_dxidz_map[p] = jacm2 * _ad_dxyzdxi_map[p](2);

      _ad_JxW[p] = _ad_jac[p] * qw[p];

      break;
    }

    case 2:
    {
      if (_calculate_xyz)
        _ad_q_points[p].zero();
      _ad_dxyzdxi_map[p].zero();
      _ad_dxyzdeta_map[p].zero();

      for (std::size_t i = 0; i < num_shapes; i++)
      {
        libmesh_assert(elem_nodes[i]);
        libMesh::VectorValue<DualReal> elem_point = *elem_nodes[i];
        unsigned dimension = 0;
        for (const auto & disp_num : _displacements)
          elem_point(dimension++).derivatives()[disp_num * _sys.getMaxVarNDofsPerElem() + i] = 1.;

        _ad_dxyzdxi_map[p].add_scaled(elem_point, dphidxi_map[i][p]);
        _ad_dxyzdeta_map[p].add_scaled(elem_point, dphideta_map[i][p]);

        if (_calculate_xyz)
          _ad_q_points[p].add_scaled(elem_point, phi_map[i][p]);
      }

      const auto &dx_dxi = _ad_dxyzdxi_map[p](0), dx_deta = _ad_dxyzdeta_map[p](0),
                 dy_dxi = _ad_dxyzdxi_map[p](1), dy_deta = _ad_dxyzdeta_map[p](1),
                 dz_dxi = _ad_dxyzdxi_map[p](2), dz_deta = _ad_dxyzdeta_map[p](2);

      const auto g11 = (dx_dxi * dx_dxi + dy_dxi * dy_dxi + dz_dxi * dz_dxi);

      const auto g12 = (dx_dxi * dx_deta + dy_dxi * dy_deta + dz_dxi * dz_deta);

      const auto g21 = g12;

      const auto g22 = (dx_deta * dx_deta + dy_deta * dy_deta + dz_deta * dz_deta);

      auto det = (g11 * g22 - g12 * g21);

      if (det.value() <= -TOLERANCE * TOLERANCE)
      {
        static bool failing = false;
        if (!failing)
        {
          failing = true;
          elem->print_info(libMesh::err);
          libmesh_error_msg("ERROR: negative Jacobian " << det << " at point index " << p
                                                        << " in element " << elem->id());
        }
        else
          return;
      }
      else if (det.value() <= 0.)
        det.value() = TOLERANCE * TOLERANCE;

      const auto inv_det = 1. / det;
      _ad_jac[p] = std::sqrt(det);

      _ad_JxW[p] = _ad_jac[p] * qw[p];

      const auto g11inv = g22 * inv_det;
      const auto g12inv = -g12 * inv_det;
      const auto g21inv = -g21 * inv_det;
      const auto g22inv = g11 * inv_det;

      _ad_dxidx_map[p] = g11inv * dx_dxi + g12inv * dx_deta;
      _ad_dxidy_map[p] = g11inv * dy_dxi + g12inv * dy_deta;
      _ad_dxidz_map[p] = g11inv * dz_dxi + g12inv * dz_deta;

      _ad_detadx_map[p] = g21inv * dx_dxi + g22inv * dx_deta;
      _ad_detady_map[p] = g21inv * dy_dxi + g22inv * dy_deta;
      _ad_detadz_map[p] = g21inv * dz_dxi + g22inv * dz_deta;

      break;
    }

    case 3:
    {
      if (_calculate_xyz)
        _ad_q_points[p].zero();
      _ad_dxyzdxi_map[p].zero();
      _ad_dxyzdeta_map[p].zero();
      _ad_dxyzdzeta_map[p].zero();

      for (std::size_t i = 0; i < num_shapes; i++)
      {
        libmesh_assert(elem_nodes[i]);
        libMesh::VectorValue<DualReal> elem_point = *elem_nodes[i];
        unsigned dimension = 0;
        for (const auto & disp_num : _displacements)
          elem_point(dimension++).derivatives()[disp_num * _sys.getMaxVarNDofsPerElem() + i] = 1.;

        _ad_dxyzdxi_map[p].add_scaled(elem_point, dphidxi_map[i][p]);
        _ad_dxyzdeta_map[p].add_scaled(elem_point, dphideta_map[i][p]);
        _ad_dxyzdzeta_map[p].add_scaled(elem_point, dphidzeta_map[i][p]);

        if (_calculate_xyz)
          _ad_q_points[p].add_scaled(elem_point, phi_map[i][p]);
      }

      const auto dx_dxi = _ad_dxyzdxi_map[p](0), dy_dxi = _ad_dxyzdxi_map[p](1),
                 dz_dxi = _ad_dxyzdxi_map[p](2), dx_deta = _ad_dxyzdeta_map[p](0),
                 dy_deta = _ad_dxyzdeta_map[p](1), dz_deta = _ad_dxyzdeta_map[p](2),
                 dx_dzeta = _ad_dxyzdzeta_map[p](0), dy_dzeta = _ad_dxyzdzeta_map[p](1),
                 dz_dzeta = _ad_dxyzdzeta_map[p](2);

      _ad_jac[p] = (dx_dxi * (dy_deta * dz_dzeta - dz_deta * dy_dzeta) +
                    dy_dxi * (dz_deta * dx_dzeta - dx_deta * dz_dzeta) +
                    dz_dxi * (dx_deta * dy_dzeta - dy_deta * dx_dzeta));

      if (_ad_jac[p].value() <= -TOLERANCE * TOLERANCE)
      {
        static bool failing = false;
        if (!failing)
        {
          failing = true;
          elem->print_info(libMesh::err);
          libmesh_error_msg("ERROR: negative Jacobian " << _ad_jac[p].value() << " at point index "
                                                        << p << " in element " << elem->id());
        }
        else
          return;
      }

      _ad_JxW[p] = _ad_jac[p] * qw[p];

      const auto inv_jac = 1. / _ad_jac[p];

      _ad_dxidx_map[p] = (dy_deta * dz_dzeta - dz_deta * dy_dzeta) * inv_jac;
      _ad_dxidy_map[p] = (dz_deta * dx_dzeta - dx_deta * dz_dzeta) * inv_jac;
      _ad_dxidz_map[p] = (dx_deta * dy_dzeta - dy_deta * dx_dzeta) * inv_jac;

      _ad_detadx_map[p] = (dz_dxi * dy_dzeta - dy_dxi * dz_dzeta) * inv_jac;
      _ad_detady_map[p] = (dx_dxi * dz_dzeta - dz_dxi * dx_dzeta) * inv_jac;
      _ad_detadz_map[p] = (dy_dxi * dx_dzeta - dx_dxi * dy_dzeta) * inv_jac;

      _ad_dzetadx_map[p] = (dy_dxi * dz_deta - dz_dxi * dy_deta) * inv_jac;
      _ad_dzetady_map[p] = (dz_dxi * dx_deta - dx_dxi * dz_deta) * inv_jac;
      _ad_dzetadz_map[p] = (dx_dxi * dy_deta - dy_dxi * dx_deta) * inv_jac;

      break;
    }

    default:
      libmesh_error_msg("Invalid dim = " << dim);
  }
}

coordSystem()

const Moose::CoordinateSystemType& Assembly::coordSystem ( )

inline

Get the coordinate system type.

Returns

A reference to the coordinate system type

Definition at line 272 of file Assembly.h.

{ return _coord_type; }

coordTransformation()

const MooseArray<Real>& Assembly::coordTransformation ( ) const

inline

Returns the reference to the coordinate transformation coefficients.

Returns

A reference. Make sure to store this as a reference!

Definition at line 256 of file Assembly.h.

{ return _coord; }

copyFaceShapes() [1/2]

template<typename T >

void Assembly::copyFaceShapes

(

MooseVariableFE< T > &

v

)

Definition at line 2188 of file Assembly.C.

Referenced by copyFaceShapes().

{
  phiFace(v).shallowCopy(v.phiFace());
  gradPhiFace(v).shallowCopy(v.gradPhiFace());
  if (v.computingSecond())
    secondPhiFace(v).shallowCopy(v.secondPhiFace());
}

copyFaceShapes() [2/2]

void Assembly::copyFaceShapes

(

unsigned int

var

)

Definition at line 2197 of file Assembly.C.

{
  try
  {
    MooseVariable & v = _sys.getFieldVariable<Real>(_tid, var);
    copyFaceShapes(v);
  }
  catch (std::out_of_range & e)
  {
    VectorMooseVariable & v = _sys.getFieldVariable<RealVectorValue>(_tid, var);
    copyFaceShapes(v);
    if (v.computingCurl())
      _vector_curl_phi_face.shallowCopy(v.curlPhi());
  }
}

copyNeighborShapes() [1/2]

template<typename T >

void Assembly::copyNeighborShapes

(

MooseVariableFE< T > &

v

)

Definition at line 2215 of file Assembly.C.

Referenced by copyNeighborShapes().

{
  if (v.usesPhiNeighbor())
  {
    phiFaceNeighbor(v).shallowCopy(v.phiFaceNeighbor());
    phiNeighbor(v).shallowCopy(v.phiNeighbor());
  }
  if (v.usesGradPhiNeighbor())
  {
    gradPhiFaceNeighbor(v).shallowCopy(v.gradPhiFaceNeighbor());
    gradPhiNeighbor(v).shallowCopy(v.gradPhiNeighbor());
  }
  if (v.usesSecondPhiNeighbor())
  {
    secondPhiFaceNeighbor(v).shallowCopy(v.secondPhiFaceNeighbor());
    secondPhiNeighbor(v).shallowCopy(v.secondPhiNeighbor());
  }
}

copyNeighborShapes() [2/2]

void Assembly::copyNeighborShapes

(

unsigned int

var

)

Definition at line 2235 of file Assembly.C.

{
  try
  {
    MooseVariable & v = _sys.getFieldVariable<Real>(_tid, var);
    copyNeighborShapes(v);
  }
  catch (std::out_of_range & e)
  {
    VectorMooseVariable & v = _sys.getFieldVariable<RealVectorValue>(_tid, var);
    copyNeighborShapes(v);
  }
}

copyShapes() [1/2]

template<typename T >

void Assembly::copyShapes

(

MooseVariableFE< T > &

v

)

Definition at line 2161 of file Assembly.C.

Referenced by copyShapes().

{
  phi(v).shallowCopy(v.phi());
  gradPhi(v).shallowCopy(v.gradPhi());
  if (v.computingSecond())
    secondPhi(v).shallowCopy(v.secondPhi());
}

copyShapes() [2/2]

void Assembly::copyShapes

(

unsigned int

var

)

Definition at line 2170 of file Assembly.C.

{
  try
  {
    MooseVariable & v = _sys.getFieldVariable<Real>(_tid, var);
    copyShapes(v);
  }
  catch (std::out_of_range & e)
  {
    VectorMooseVariable & v = _sys.getFieldVariable<RealVectorValue>(_tid, var);
    copyShapes(v);
    if (v.computingCurl())
      curlPhi(v).shallowCopy(v.curlPhi());
  }
}

couplingEntries()

std::vector<std::pair<MooseVariableFEBase *, MooseVariableFEBase *> >& Assembly::couplingEntries ( )

inline

Definition at line 688 of file Assembly.h.

  {
    return _cm_ff_entry;
  }

createQRules()

void Assembly::createQRules	(	QuadratureType	type,
		Order	order,
		Order	volume_order,
		Order	face_order
	)

Creates the volume, face and arbitrary qrules based on the orders passed in.

Definition at line 421 of file Assembly.C.

{
  _holder_qrule_volume.clear();
  for (unsigned int dim = 0; dim <= _mesh_dimension; dim++)
    _holder_qrule_volume[dim] = QBase::build(type, dim, volume_order).release();

  _holder_qrule_face.clear();
  for (unsigned int dim = 0; dim <= _mesh_dimension; dim++)
    _holder_qrule_face[dim] = QBase::build(type, dim - 1, face_order).release();

  _holder_qrule_neighbor.clear();
  for (unsigned int dim = 0; dim <= _mesh_dimension; dim++)
    _holder_qrule_neighbor[dim] = new ArbitraryQuadrature(dim, face_order);

  _holder_qrule_arbitrary.clear();
  for (unsigned int dim = 0; dim <= _mesh_dimension; dim++)
    _holder_qrule_arbitrary[dim] = new ArbitraryQuadrature(dim, order);
}

curlPhi() [1/2]

const VectorVariablePhiCurl& Assembly::curlPhi ( const VectorMooseVariable &  ) const

inline

Definition at line 749 of file Assembly.h.

Referenced by copyShapes().

  {
    return _vector_curl_phi;
  }

curlPhi() [2/2]

VectorVariablePhiCurl& Assembly::curlPhi ( const VectorMooseVariable &  )

inline

Definition at line 831 of file Assembly.h.

{ return _vector_curl_phi; }

curlPhiFace() [1/2]

const VectorVariablePhiCurl& Assembly::curlPhiFace ( const VectorMooseVariable &  ) const

inline

Definition at line 766 of file Assembly.h.

  {
    return _vector_curl_phi_face;
  }

curlPhiFace() [2/2]

VectorVariablePhiCurl& Assembly::curlPhiFace ( const VectorMooseVariable &  )

inline

Definition at line 842 of file Assembly.h.

{ return _vector_curl_phi_face; }

curlPhiFaceNeighbor() [1/2]

const VectorVariablePhiCurl& Assembly::curlPhiFaceNeighbor ( const VectorMooseVariable &  ) const

inline

Definition at line 800 of file Assembly.h.

  {
    return _vector_curl_phi_face_neighbor;
  }

curlPhiFaceNeighbor() [2/2]

VectorVariablePhiCurl& Assembly::curlPhiFaceNeighbor ( const VectorMooseVariable &  )

inline

Definition at line 870 of file Assembly.h.

  {
    return _vector_curl_phi_face_neighbor;
  }

curlPhiNeighbor() [1/2]

const VectorVariablePhiCurl& Assembly::curlPhiNeighbor ( const VectorMooseVariable &  ) const

inline

Definition at line 783 of file Assembly.h.

  {
    return _vector_curl_phi_neighbor;
  }

curlPhiNeighbor() [2/2]

VectorVariablePhiCurl& Assembly::curlPhiNeighbor ( const VectorMooseVariable &  )

inline

Definition at line 853 of file Assembly.h.

  {
    return _vector_curl_phi_neighbor;
  }

currentNeighborSubdomainID()

const SubdomainID& Assembly::currentNeighborSubdomainID ( ) const

inline

Return the current subdomain ID.

Definition at line 371 of file Assembly.h.

{ return _current_neighbor_subdomain_id; }

currentSubdomainID()

const SubdomainID& Assembly::currentSubdomainID ( ) const

inline

Return the current subdomain ID.

Definition at line 325 of file Assembly.h.

{ return _current_subdomain_id; }

elem()

const Elem*& Assembly::elem ( )

inline

Return the current element.

Returns

A reference. Make sure to store this as a reference!

Definition at line 320 of file Assembly.h.

Referenced by computeAffineMapAD(), computeFaceMap(), computeGradPhiAD(), computeSinglePointMapAD(), modifyFaceWeightsDueToXFEM(), modifyWeightsDueToXFEM(), reinit(), reinitAtPhysical(), reinitElemAndNeighbor(), reinitFE(), and reinitFEFace().

{ return _current_elem; }

elemVolume()

const Real& Assembly::elemVolume ( )

inline

Returns the reference to the current element volume.

Returns

A reference. Make sure to store this as a reference!

Definition at line 336 of file Assembly.h.

{ return _current_elem_volume; }

feADGradPhi() [1/2]

template<typename OutputType >

const VariableTestGradientType<OutputType, ComputeStage::JACOBIAN>::type& Assembly::feADGradPhi ( FEType  type )

inline

Definition at line 891 of file Assembly.h.

  {
    return _ad_grad_phi_data[type];
  }

feADGradPhi() [2/2]

template<>

const VariableTestGradientType<RealVectorValue, ComputeStage::JACOBIAN>::type& Assembly::feADGradPhi ( FEType  type )

inline

Definition at line 1488 of file Assembly.h.

{
  return _ad_vector_grad_phi_data[type];
}

feADGradPhiFace() [1/2]

template<typename OutputType >

const VariableTestGradientType<OutputType, ComputeStage::JACOBIAN>::type& Assembly::feADGradPhiFace ( FEType  type )

inline

Definition at line 920 of file Assembly.h.

  {
    return _ad_grad_phi_data_face[type];
  }

feADGradPhiFace() [2/2]

template<>

const VariableTestGradientType<RealVectorValue, ComputeStage::JACOBIAN>::type& Assembly::feADGradPhiFace ( FEType  type )

inline

Definition at line 1495 of file Assembly.h.

{
  return _ad_vector_grad_phi_data_face[type];
}

feCurlPhi() [1/3]

template<typename OutputType >

const OutputTools<OutputType>::VariablePhiCurl& Assembly::feCurlPhi ( FEType  type )

inline

Definition at line 978 of file Assembly.h.

  {
    _need_curl[type] = true;
    buildFE(type);
    return _fe_shape_data[type]->_curl_phi;
  }

feCurlPhi() [2/3]

template<>

const OutputTools<VectorValue<Real> >::VariablePhiCurl& Assembly::feCurlPhi

(

FEType

type

)

feCurlPhi() [3/3]

template<>

const OutputTools<VectorValue<Real> >::VariablePhiCurl& Assembly::feCurlPhi

(

FEType

type

)

Definition at line 3167 of file Assembly.C.

{
  _need_curl[type] = true;
  buildVectorFE(type);
  return _vector_fe_shape_data[type]->_curl_phi;
}

feCurlPhiFace() [1/3]

template<typename OutputType >

const OutputTools<OutputType>::VariablePhiCurl& Assembly::feCurlPhiFace ( FEType  type )

inline

Definition at line 986 of file Assembly.h.

  {
    _need_curl[type] = true;
    buildFaceFE(type);
    return _fe_shape_data_face[type]->_curl_phi;
  }

feCurlPhiFace() [2/3]

template<>

const OutputTools<VectorValue<Real> >::VariablePhiCurl& Assembly::feCurlPhiFace

(

FEType

type

)

feCurlPhiFace() [3/3]

template<>

const OutputTools<VectorValue<Real> >::VariablePhiCurl& Assembly::feCurlPhiFace

(

FEType

type

)

Definition at line 3176 of file Assembly.C.

{
  _need_curl[type] = true;
  buildVectorFaceFE(type);
  return _vector_fe_shape_data_face[type]->_curl_phi;
}

feCurlPhiFaceNeighbor() [1/3]

template<typename OutputType >

const OutputTools<OutputType>::VariablePhiCurl& Assembly::feCurlPhiFaceNeighbor ( FEType  type )

inline

Definition at line 1002 of file Assembly.h.

  {
    _need_curl[type] = true;
    buildFaceNeighborFE(type);
    return _fe_shape_data_face_neighbor[type]->_curl_phi;
  }

feCurlPhiFaceNeighbor() [2/3]

template<>

const OutputTools<VectorValue<Real> >::VariablePhiCurl& Assembly::feCurlPhiFaceNeighbor

(

FEType

type

)

feCurlPhiFaceNeighbor() [3/3]

template<>

const OutputTools<VectorValue<Real> >::VariablePhiCurl& Assembly::feCurlPhiFaceNeighbor

(

FEType

type

)

Definition at line 3194 of file Assembly.C.

{
  _need_curl[type] = true;
  buildVectorFaceNeighborFE(type);
  return _vector_fe_shape_data_face_neighbor[type]->_curl_phi;
}

feCurlPhiNeighbor() [1/3]

template<typename OutputType >

const OutputTools<OutputType>::VariablePhiCurl& Assembly::feCurlPhiNeighbor ( FEType  type )

inline

Definition at line 994 of file Assembly.h.

  {
    _need_curl[type] = true;
    buildNeighborFE(type);
    return _fe_shape_data_neighbor[type]->_curl_phi;
  }

feCurlPhiNeighbor() [2/3]

template<>

const OutputTools<VectorValue<Real> >::VariablePhiCurl& Assembly::feCurlPhiNeighbor

(

FEType

type

)

feCurlPhiNeighbor() [3/3]

template<>

const OutputTools<VectorValue<Real> >::VariablePhiCurl& Assembly::feCurlPhiNeighbor

(

FEType

type

)

Definition at line 3185 of file Assembly.C.

{
  _need_curl[type] = true;
  buildVectorNeighborFE(type);
  return _vector_fe_shape_data_neighbor[type]->_curl_phi;
}

feGradPhi() [1/3]

template<typename OutputType >

const OutputTools<OutputType>::VariablePhiGradient& Assembly::feGradPhi ( FEType  type )

inline

Definition at line 883 of file Assembly.h.

  {
    buildFE(type);
    return _fe_shape_data[type]->_grad_phi;
  }

feGradPhi() [2/3]

template<>

const OutputTools<VectorValue<Real> >::VariablePhiGradient& Assembly::feGradPhi

(

FEType

type

)

feGradPhi() [3/3]

template<>

const OutputTools<VectorValue<Real> >::VariablePhiGradient& Assembly::feGradPhi

(

FEType

type

)

Definition at line 3075 of file Assembly.C.

{
  buildVectorFE(type);
  return _vector_fe_shape_data[type]->_grad_phi;
}

feGradPhiFace() [1/3]

template<typename OutputType >

const OutputTools<OutputType>::VariablePhiGradient& Assembly::feGradPhiFace ( FEType  type )

inline

Definition at line 912 of file Assembly.h.

  {
    buildFaceFE(type);
    return _fe_shape_data_face[type]->_grad_phi;
  }

feGradPhiFace() [2/3]

template<>

const OutputTools<VectorValue<Real> >::VariablePhiGradient& Assembly::feGradPhiFace

(

FEType

type

)

feGradPhiFace() [3/3]

template<>

const OutputTools<VectorValue<Real> >::VariablePhiGradient& Assembly::feGradPhiFace

(

FEType

type

)

Definition at line 3100 of file Assembly.C.

{
  buildVectorFaceFE(type);
  return _vector_fe_shape_data_face[type]->_grad_phi;
}

feGradPhiFaceNeighbor() [1/3]

template<typename OutputType >

const OutputTools<OutputType>::VariablePhiGradient& Assembly::feGradPhiFaceNeighbor ( FEType  type )

inline

Definition at line 963 of file Assembly.h.

  {
    buildFaceNeighborFE(type);
    return _fe_shape_data_face_neighbor[type]->_grad_phi;
  }

feGradPhiFaceNeighbor() [2/3]

template<>

const OutputTools<VectorValue<Real> >::VariablePhiGradient& Assembly::feGradPhiFaceNeighbor

(

FEType

type

)

feGradPhiFaceNeighbor() [3/3]

template<>

const OutputTools<VectorValue<Real> >::VariablePhiGradient& Assembly::feGradPhiFaceNeighbor

(

FEType

type

)

Definition at line 3150 of file Assembly.C.

{
  buildVectorFaceNeighborFE(type);
  return _vector_fe_shape_data_face_neighbor[type]->_grad_phi;
}

feGradPhiNeighbor() [1/3]

template<typename OutputType >

const OutputTools<OutputType>::VariablePhiGradient& Assembly::feGradPhiNeighbor ( FEType  type )

inline

Definition at line 941 of file Assembly.h.

  {
    buildNeighborFE(type);
    return _fe_shape_data_neighbor[type]->_grad_phi;
  }

feGradPhiNeighbor() [2/3]

template<>

const OutputTools<VectorValue<Real> >::VariablePhiGradient& Assembly::feGradPhiNeighbor

(

FEType

type

)

feGradPhiNeighbor() [3/3]

template<>

const OutputTools<VectorValue<Real> >::VariablePhiGradient& Assembly::feGradPhiNeighbor

(

FEType

type

)

Definition at line 3125 of file Assembly.C.

{
  buildVectorNeighborFE(type);
  return _vector_fe_shape_data_neighbor[type]->_grad_phi;
}

fePhi() [1/3]

template<typename OutputType >

const OutputTools<OutputType>::VariablePhiValue& Assembly::fePhi ( FEType  type )

inline

Definition at line 876 of file Assembly.h.

  {
    buildFE(type);
    return _fe_shape_data[type]->_phi;
  }

fePhi() [2/3]

template<>

const OutputTools<VectorValue<Real> >::VariablePhiValue& Assembly::fePhi

(

FEType

type

)

fePhi() [3/3]

template<>

const OutputTools<VectorValue<Real> >::VariablePhiValue& Assembly::fePhi

(

FEType

type

)

Definition at line 3067 of file Assembly.C.

{
  buildVectorFE(type);
  return _vector_fe_shape_data[type]->_phi;
}

fePhiFace() [1/3]

template<typename OutputType >

const OutputTools<OutputType>::VariablePhiValue& Assembly::fePhiFace ( FEType  type )

inline

Definition at line 905 of file Assembly.h.

  {
    buildFaceFE(type);
    return _fe_shape_data_face[type]->_phi;
  }

fePhiFace() [2/3]

template<>

const OutputTools<VectorValue<Real> >::VariablePhiValue& Assembly::fePhiFace

(

FEType

type

)

fePhiFace() [3/3]

template<>

const OutputTools<VectorValue<Real> >::VariablePhiValue& Assembly::fePhiFace

(

FEType

type

)

Definition at line 3092 of file Assembly.C.

{
  buildVectorFaceFE(type);
  return _vector_fe_shape_data_face[type]->_phi;
}

fePhiFaceNeighbor() [1/3]

template<typename OutputType >

const OutputTools<OutputType>::VariablePhiValue& Assembly::fePhiFaceNeighbor ( FEType  type )

inline

Definition at line 956 of file Assembly.h.

  {
    buildFaceNeighborFE(type);
    return _fe_shape_data_face_neighbor[type]->_phi;
  }

fePhiFaceNeighbor() [2/3]

template<>

const OutputTools<VectorValue<Real> >::VariablePhiValue& Assembly::fePhiFaceNeighbor

(

FEType

type

)

fePhiFaceNeighbor() [3/3]

template<>

const OutputTools<VectorValue<Real> >::VariablePhiValue& Assembly::fePhiFaceNeighbor

(

FEType

type

)

Definition at line 3142 of file Assembly.C.

{
  buildVectorFaceNeighborFE(type);
  return _vector_fe_shape_data_face_neighbor[type]->_phi;
}

fePhiNeighbor() [1/3]

template<typename OutputType >

const OutputTools<OutputType>::VariablePhiValue& Assembly::fePhiNeighbor ( FEType  type )

inline

Definition at line 934 of file Assembly.h.

  {
    buildNeighborFE(type);
    return _fe_shape_data_neighbor[type]->_phi;
  }

fePhiNeighbor() [2/3]

template<>

const OutputTools<VectorValue<Real> >::VariablePhiValue& Assembly::fePhiNeighbor

(

FEType

type

)

fePhiNeighbor() [3/3]

template<>

const OutputTools<VectorValue<Real> >::VariablePhiValue& Assembly::fePhiNeighbor

(

FEType

type

)

Definition at line 3117 of file Assembly.C.

{
  buildVectorNeighborFE(type);
  return _vector_fe_shape_data_neighbor[type]->_phi;
}

feSecondPhi() [1/3]

template<typename OutputType >

const OutputTools<OutputType>::VariablePhiSecond& Assembly::feSecondPhi ( FEType  type )

inline

Definition at line 897 of file Assembly.h.

  {
    _need_second_derivative[type] = true;
    buildFE(type);
    return _fe_shape_data[type]->_second_phi;
  }

feSecondPhi() [2/3]

template<>

const OutputTools<VectorValue<Real> >::VariablePhiSecond& Assembly::feSecondPhi

(

FEType

type

)

feSecondPhi() [3/3]

template<>

const OutputTools<VectorValue<Real> >::VariablePhiSecond& Assembly::feSecondPhi

(

FEType

type

)

Definition at line 3083 of file Assembly.C.

{
  _need_second_derivative[type] = true;
  buildVectorFE(type);
  return _vector_fe_shape_data[type]->_second_phi;
}

feSecondPhiFace() [1/3]

template<typename OutputType >

const OutputTools<OutputType>::VariablePhiSecond& Assembly::feSecondPhiFace ( FEType  type )

inline

Definition at line 926 of file Assembly.h.

  {
    _need_second_derivative[type] = true;
    buildFaceFE(type);
    return _fe_shape_data_face[type]->_second_phi;
  }

feSecondPhiFace() [2/3]

template<>

const OutputTools<VectorValue<Real> >::VariablePhiSecond& Assembly::feSecondPhiFace

(

FEType

type

)

feSecondPhiFace() [3/3]

template<>

const OutputTools<VectorValue<Real> >::VariablePhiSecond& Assembly::feSecondPhiFace

(

FEType

type

)

Definition at line 3108 of file Assembly.C.

{
  _need_second_derivative[type] = true;
  buildVectorFaceFE(type);
  return _vector_fe_shape_data_face[type]->_second_phi;
}

feSecondPhiFaceNeighbor() [1/3]

template<typename OutputType >

const OutputTools<OutputType>::VariablePhiSecond& Assembly::feSecondPhiFaceNeighbor ( FEType  type )

inline

Definition at line 970 of file Assembly.h.

  {
    _need_second_derivative_neighbor[type] = true;
    buildFaceNeighborFE(type);
    return _fe_shape_data_face_neighbor[type]->_second_phi;
  }

feSecondPhiFaceNeighbor() [2/3]

template<>

const OutputTools<VectorValue<Real> >::VariablePhiSecond& Assembly::feSecondPhiFaceNeighbor

(

FEType

type

)

feSecondPhiFaceNeighbor() [3/3]

template<>

const OutputTools<VectorValue<Real> >::VariablePhiSecond& Assembly::feSecondPhiFaceNeighbor

(

FEType

type

)

Definition at line 3158 of file Assembly.C.

{
  _need_second_derivative_neighbor[type] = true;
  buildVectorFaceNeighborFE(type);
  return _vector_fe_shape_data_face_neighbor[type]->_second_phi;
}

feSecondPhiNeighbor() [1/3]

template<typename OutputType >

const OutputTools<OutputType>::VariablePhiSecond& Assembly::feSecondPhiNeighbor ( FEType  type )

inline

Definition at line 948 of file Assembly.h.

  {
    _need_second_derivative_neighbor[type] = true;
    buildNeighborFE(type);
    return _fe_shape_data_neighbor[type]->_second_phi;
  }

feSecondPhiNeighbor() [2/3]

template<>

const OutputTools<VectorValue<Real> >::VariablePhiSecond& Assembly::feSecondPhiNeighbor

(

FEType

type

)

feSecondPhiNeighbor() [3/3]

template<>

const OutputTools<VectorValue<Real> >::VariablePhiSecond& Assembly::feSecondPhiNeighbor

(

FEType

type

)

Definition at line 3133 of file Assembly.C.

{
  _need_second_derivative_neighbor[type] = true;
  buildVectorNeighborFE(type);
  return _vector_fe_shape_data_neighbor[type]->_second_phi;
}

getFE()

FEBase*& Assembly::getFE ( FEType  type, unsigned int  dim  )

inline

Get a reference to a pointer that will contain the current volume FE.

Parameters

type	The type of FE
dim	The dimension of the current volume

Returns

A reference to the pointer. Make sure to store this as a reference!

Definition at line 123 of file Assembly.h.

Referenced by MortarConstraint::computeJacobian(), MooseVariableFE< Real >::MooseVariableFE(), and MortarConstraint::reinit().

  {
    buildFE(type);
    return _fe[dim][type];
  }

getFEFace()

FEBase*& Assembly::getFEFace ( FEType  type, unsigned int  dim  )

inline

Get a reference to a pointer that will contain the current "face" FE.

Parameters

type	The type of FE
dim	The dimension of the current face

Returns

A reference to the pointer. Make sure to store this as a reference!

Definition at line 147 of file Assembly.h.

  {
    buildFaceFE(type);
    return _fe_face[dim][type];