Assembly Class Reference

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

#include <Assembly.h>

Classes
class	FEShapeData
class	GlobalDataKey
	Key structure for APIs manipulating global vectors/matrices. More...
class	LocalDataKey
	Key structure for APIs adding/caching local element residuals/Jacobians. More...
struct	QRules
	Data structure for tracking/grouping a set of quadrature rules for a particular dimensionality of mesh element. More...
class	VectorFEShapeData

Public Types
using	InternalDataKey = Moose::PassKey< Moose::Kokkos::Assembly >
	Key structure for APIs manipulating internal shape and quadrature data.

Public Member Functions
	Assembly (SystemBase &sys, THREAD_ID tid)
virtual	~Assembly ()
const FEBase *const &	getFE (FEType type, unsigned int dim) const
	Get a reference to a pointer that will contain the current volume FE.
const FEBase *const &	getFENeighbor (FEType type, unsigned int dim) const
	Get a reference to a pointer that will contain the current 'neighbor' FE.
const FEBase *const &	getFEFace (FEType type, unsigned int dim) const
	Get a reference to a pointer that will contain the current "face" FE.
const FEBase *const &	getFEFaceNeighbor (FEType type, unsigned int dim) const
	Get a reference to a pointer that will contain the current "neighbor" FE.
const FEVectorBase *const &	getVectorFE (FEType type, unsigned int dim) const
	Get a reference to a pointer that will contain the current volume FEVector.
const FEVectorBase *const &	getVectorFENeighbor (FEType type, unsigned int dim) const
	GetVector a reference to a pointer that will contain the current 'neighbor' FE.
const FEVectorBase *const &	getVectorFEFace (FEType type, unsigned int dim) const
	GetVector a reference to a pointer that will contain the current "face" FE.
const FEVectorBase *const &	getVectorFEFaceNeighbor (FEType type, unsigned int dim) const
	GetVector a reference to a pointer that will contain the current "neighbor" FE.
const libMesh::QBase *const &	qRule () const
	Returns the reference to the current quadrature being used.
libMesh::QBase *const &	writeableQRule ()
	Returns the reference to the current quadrature being used.
libMesh::QBase *	writeableQRule (unsigned int dim, SubdomainID block, InternalDataKey)
	Returns the pointer to the quadrature of specified block and dimension.
const MooseArray< Point > &	qPoints () const
	Returns the reference to the quadrature points.
const std::vector< Point > &	qPointsMortar () const
	Returns the reference to the mortar segment element quadrature points.
const MooseArray< Point > &	physicalPoints () const
	The current points in physical space where we have reinited through reinitAtPhysical()
const MooseArray< Real > &	JxW () const
	Returns the reference to the transformed jacobian weights.
const MooseArray< ADReal > &	adJxW () const
const MooseArray< ADReal > &	adJxWFace () const
const MooseArray< ADReal > &	adCurvatures () const
const MooseArray< Real > &	coordTransformation () const
	Returns the reference to the coordinate transformation coefficients.
const MooseArray< Real > &	mortarCoordTransformation () const
	Returns the reference to the coordinate transformation coefficients on the mortar segment mesh.
const MooseArray< ADReal > &	adCoordTransformation () const
	Returns the reference to the AD version of the coordinate transformation coefficients.
const Moose::CoordinateSystemType &	coordSystem () const
	Get the coordinate system type.
const libMesh::QBase *const &	qRuleFace () const
	Returns the reference to the current quadrature being used on a current face.
libMesh::QBase *const &	writeableQRuleFace ()
	Returns the reference to the current quadrature being used on a current face.
libMesh::QBase *	writeableQRuleFace (unsigned int dim, SubdomainID block, InternalDataKey)
	Returns the pointer to the quadrature used on a face of specified block and dimension.
const MooseArray< Point > &	qPointsFace () const
	Returns the reference to the current quadrature being used.
const MooseArray< Real > &	JxWFace () const
	Returns the reference to the transformed jacobian weights on a current face.
const MooseArray< Point > &	normals () const
	Returns the array of normals for quadrature points on a current side.
const std::vector< Eigen::Map< RealDIMValue > > &	mappedNormals () const
const MooseArray< std::vector< Point > > &	tangents () const
	Returns the array of tangents for quadrature points on a current side.
unsigned int	numExtraElemIntegers () const
	Number of extra element integers Assembly tracked.
const dof_id_type &	extraElemID (unsigned int id) const
	Returns an integer ID of the current element given the index associated with the integer.
const dof_id_type &	extraElemIDNeighbor (unsigned int id) const
	Returns an integer ID of the current element given the index associated with the integer.
const MooseArray< ADPoint > &	adNormals () const
const MooseArray< ADPoint > &	adQPoints () const
const MooseArray< ADPoint > &	adQPointsFace () const
template<bool is_ad>
const MooseArray< Moose::GenericType< Point, is_ad > > &	genericQPoints () const
const Elem *const &	elem () const
	Return the current element.
const SubdomainID &	currentSubdomainID () const
	Return the current subdomain ID.
void	setCurrentSubdomainID (SubdomainID i)
	set the current subdomain ID
const BoundaryID &	currentBoundaryID () const
	Return the current boundary ID.
void	setCurrentBoundaryID (BoundaryID i)
	set the current boundary ID
const Real &	elemVolume () const
	Returns the reference to the current element volume.
const unsigned int &	side () const
	Returns the current side.
const unsigned int &	neighborSide () const
	Returns the current neighboring side.
const Elem *const &	sideElem () const
	Returns the side element.
const Real &	sideElemVolume () const
	Returns the reference to the volume of current side element.
const Elem *const &	neighbor () const
	Return the neighbor element.
const Elem *const &	lowerDElem () const
	Return the lower dimensional element.
const Elem *const &	neighborLowerDElem () const
	Return the neighboring lower dimensional element.
const Real &	lowerDElemVolume () const
const Real &	neighborLowerDElemVolume () const
const SubdomainID &	currentNeighborSubdomainID () const
	Return the current subdomain ID.
void	setCurrentNeighborSubdomainID (SubdomainID i)
	set the current subdomain ID
const Real &	neighborVolume ()
	Returns the reference to the current neighbor volume.
const libMesh::QBase *const &	qRuleNeighbor () const
	Returns the reference to the current quadrature being used on a current neighbor.
libMesh::QBase *const &	writeableQRuleNeighbor ()
	Returns the reference to the current quadrature being used on a current neighbor.
const MooseArray< Real > &	JxWNeighbor () const
	Returns the reference to the transformed jacobian weights on a current face.
const MooseArray< Point > &	qPointsFaceNeighbor () const
	Returns the reference to the current quadrature points being used on the neighbor face.
const Node *const &	node () const
	Returns the reference to the node.
const Node *const &	nodeNeighbor () const
	Returns the reference to the neighboring node.
void	createQRules (QuadratureType type, Order order, Order volume_order, Order face_order, SubdomainID block, bool allow_negative_qweights=true)
	Creates block-specific volume, face and arbitrary qrules based on the orders and the flag of whether or not to allow negative qweights passed in.
void	bumpVolumeQRuleOrder (Order volume_order, SubdomainID block)
	Increases the element/volume quadrature order for the specified mesh block if and only if the current volume quadrature order is lower.
void	bumpAllQRuleOrder (Order order, SubdomainID block)
	Increases the element/volume and face/area quadrature orders for the specified mesh block if and only if the current volume or face quadrature order is lower.
void	setVolumeQRule (libMesh::QBase *qrule, unsigned int dim)
	Set the qrule to be used for volume integration.
void	setFaceQRule (libMesh::QBase *qrule, unsigned int dim)
	Set the qrule to be used for face integration.
void	setMortarQRule (Order order)
	Specifies a custom qrule for integration on mortar segment mesh.
void	activateDual ()
	Indicates that dual shape functions are used for mortar constraint.
bool	needDual () const
	Indicates whether dual shape functions are used (computation is now repeated on each element so expense of computing dual shape functions is no longer trivial)
void	clearCachedQRules ()
	Set the cached quadrature rules to nullptr.
void	setNeighborQRule (libMesh::QBase *qrule, unsigned int dim)
	Set the qrule to be used for neighbor integration.
void	reinit (const Elem *elem)
	Reinitialize objects (JxW, q_points, ...) for an elements.
void	setVolumeQRule (const Elem *elem)
	Set the volumetric quadrature rule based on the provided element.
void	reinitElemFaceRef (const Elem *elem, unsigned int elem_side, Real tolerance, const std::vector< Point > *const pts=nullptr, const std::vector< Real > *const weights=nullptr)
	Reinitialize FE data for the given element on the given side, optionally with a given set of reference points.
void	reinitNeighborFaceRef (const Elem *neighbor_elem, unsigned int neighbor_side, Real tolerance, const std::vector< Point > *const pts, const std::vector< Real > *const weights=nullptr)
	Reinitialize FE data for the given neighbor_element on the given side with a given set of reference points.
void	reinitDual (const Elem *elem, const std::vector< Point > &pts, const std::vector< Real > &JxW)
	Reintialize dual basis coefficients based on a customized quadrature rule.
void	reinitLowerDElem (const Elem *elem, const std::vector< Point > *const pts=nullptr, const std::vector< Real > *const weights=nullptr)
	Reinitialize FE data for a lower dimenesional element with a given set of reference points.
void	reinitNeighborLowerDElem (const Elem *elem)
	reinitialize a neighboring lower dimensional element
void	reinitMortarElem (const Elem *elem)
	reinitialize a mortar segment mesh element in order to get a proper JxW
const std::vector< Real > &	jxWMortar () const
	Returns a reference to JxW for mortar segment elements.
const libMesh::QBase *const &	qRuleMortar () const
	Returns a reference to the quadrature rule for the mortar segments.
void	reinitAtPhysical (const Elem *elem, const std::vector< Point > &physical_points)
	Reinitialize the assembly data at specific physical point in the given element.
void	reinit (const Elem *elem, const std::vector< Point > &reference_points)
	Reinitialize the assembly data at specific points in the reference element.
void	setFaceQRule (const Elem *const elem, const unsigned int side)
	Set the face quadrature rule based on the provided element and side.
void	reinit (const Elem *elem, unsigned int side)
	Reinitialize the assembly data on an side of an element.
void	reinit (const Elem *elem, unsigned int side, const std::vector< Point > &reference_points)
	Reinitialize the assembly data on the side of a element at the custom reference points.
void	reinitFVFace (const FaceInfo &fi)
void	reinitElemAndNeighbor (const Elem *elem, unsigned int side, const Elem *neighbor, unsigned int neighbor_side, const std::vector< Point > *neighbor_reference_points=nullptr)
	Reinitialize an element and its neighbor along a particular side.
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.
void	reinitNeighborAtPhysical (const Elem *neighbor, const std::vector< Point > &physical_points)
	Reinitializes the neighbor at the physical coordinates within element given.
void	reinitNeighbor (const Elem *neighbor, const std::vector< Point > &reference_points)
	Reinitializes the neighbor side using reference coordinates.
void	reinit (const Node *node)
	Reinitialize assembly data for a node.
void	init (const libMesh::CouplingMatrix *cm)
	Initialize the Assembly object and set the CouplingMatrix for use throughout.
void	initNonlocalCoupling ()
	Create pair of variables requiring nonlocal jacobian contributions.
void	prepareJacobianBlock ()
	Sizes and zeroes the Jacobian blocks used for the current element.
void	prepareResidual ()
	Sizes and zeroes the residual for the current element.
void	prepare ()
void	prepareNonlocal ()
void	prepareVariable (MooseVariableFieldBase *var)
	Used for preparing the dense residual and jacobian blocks for one particular variable.
void	prepareVariableNonlocal (MooseVariableFieldBase *var)
void	prepareNeighbor ()
void	prepareLowerD ()
	Prepare the Jacobians and residuals for a lower dimensional element.
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 (MooseVariableField< T > &v)
void	copyShapes (unsigned int var)
template<typename T >
void	copyFaceShapes (MooseVariableField< T > &v)
void	copyFaceShapes (unsigned int var)
template<typename T >
void	copyNeighborShapes (MooseVariableField< T > &v)
void	copyNeighborShapes (unsigned int var)
void	addResidual (GlobalDataKey, const std::vector< VectorTag > &vector_tags)
	Add local residuals of all field variables for a set of tags onto the global residual vectors associated with the tags.
void	addResidualNeighbor (GlobalDataKey, const std::vector< VectorTag > &vector_tags)
	Add local neighbor residuals of all field variables for a set of tags onto the global residual vectors associated with the tags.
void	addResidualLower (GlobalDataKey, const std::vector< VectorTag > &vector_tags)
	Add local neighbor residuals of all field variables for a set of tags onto the global residual vectors associated with the tags.
void	addResidualScalar (GlobalDataKey, const std::vector< VectorTag > &vector_tags)
	Add residuals of all scalar variables for a set of tags onto the global residual vectors associated with the tags.
void	cacheResidual (GlobalDataKey, const std::vector< VectorTag > &tags)
	Takes the values that are currently in _sub_Re of all field variables and appends them to the cached values.
void	cacheResidualNeighbor (GlobalDataKey, const std::vector< VectorTag > &tags)
	Takes the values that are currently in _sub_Rn of all field variables and appends them to the cached values.
void	cacheResidualLower (GlobalDataKey, const std::vector< VectorTag > &tags)
	Takes the values that are currently in _sub_Rl and appends them to the cached values.
void	addCachedResiduals (GlobalDataKey, const std::vector< VectorTag > &tags)
	Pushes all cached residuals to the global residual vectors associated with each tag.
void	clearCachedResiduals (GlobalDataKey)
	Clears all of the residuals in _cached_residual_rows and _cached_residual_values.
void	addCachedResidualDirectly (NumericVector< Number > &residual, GlobalDataKey, const VectorTag &vector_tag)
	Adds the values that have been cached by calling cacheResidual(), cacheResidualNeighbor(), and/or cacheResidualLower() to a user-defined residual (that is, not necessarily the vector that vector_tag points to)
void	setResidual (NumericVector< Number > &residual, GlobalDataKey, const VectorTag &vector_tag)
	Sets local residuals of all field variables to the global residual vector for a tag.
void	setResidualNeighbor (NumericVector< Number > &residual, GlobalDataKey, const VectorTag &vector_tag)
	Sets local neighbor residuals of all field variables to the global residual vector for a tag.
void	addJacobian (GlobalDataKey)
	Adds all local Jacobian to the global Jacobian matrices.
void	addJacobianNonlocal (GlobalDataKey)
	Adds non-local Jacobian to the global Jacobian matrices.
void	addJacobianNeighbor (GlobalDataKey)
	Add ElementNeighbor, NeighborElement, and NeighborNeighbor portions of the Jacobian for compute objects like DGKernels.
void	addJacobianScalar (GlobalDataKey)
	Add Jacobians for pairs of scalar variables into the global Jacobian matrices.
void	addJacobianOffDiagScalar (unsigned int ivar, GlobalDataKey)
	Add Jacobians for a scalar variables with all other field variables into the global Jacobian matrices.
void	addJacobianBlock (libMesh::SparseMatrix< Number > &jacobian, unsigned int ivar, unsigned int jvar, const libMesh::DofMap &dof_map, std::vector< dof_id_type > &dof_indices, GlobalDataKey, TagID tag)
	Adds element matrix for ivar rows and jvar columns to the global Jacobian matrix.
void	addJacobianBlockTags (libMesh::SparseMatrix< Number > &jacobian, unsigned int ivar, unsigned int jvar, const libMesh::DofMap &dof_map, std::vector< dof_id_type > &dof_indices, GlobalDataKey, const std::set< TagID > &tags)
	Add element matrix for ivar rows and jvar columns to the global Jacobian matrix for given tags.
void	addJacobianBlockNonlocal (libMesh::SparseMatrix< Number > &jacobian, unsigned int ivar, unsigned int jvar, const libMesh::DofMap &dof_map, const std::vector< dof_id_type > &idof_indices, const std::vector< dof_id_type > &jdof_indices, GlobalDataKey, TagID tag)
	Adds non-local element matrix for ivar rows and jvar columns to the global Jacobian matrix.
void	addJacobianBlockNonlocalTags (libMesh::SparseMatrix< Number > &jacobian, unsigned int ivar, unsigned int jvar, const libMesh::DofMap &dof_map, const std::vector< dof_id_type > &idof_indices, const std::vector< dof_id_type > &jdof_indices, GlobalDataKey, const std::set< TagID > &tags)
	Adds non-local element matrix for ivar rows and jvar columns to the global Jacobian matrix.
void	addJacobianNeighborLowerD (GlobalDataKey)
	Add all portions of the Jacobian except PrimaryPrimary, e.g.
void	addJacobianLowerD (GlobalDataKey)
	Add portions of the Jacobian of LowerLower, LowerSecondary, and SecondaryLower for boundary conditions.
void	cacheJacobianMortar (GlobalDataKey)
	Cache all portions of the Jacobian, e.g.
void	addJacobianNeighbor (libMesh::SparseMatrix< Number > &jacobian, unsigned int ivar, unsigned int jvar, const libMesh::DofMap &dof_map, std::vector< dof_id_type > &dof_indices, std::vector< dof_id_type > &neighbor_dof_indices, GlobalDataKey, TagID tag)
	Adds three neighboring element matrices for ivar rows and jvar columns to the global Jacobian matrix.
void	addJacobianNeighborTags (libMesh::SparseMatrix< Number > &jacobian, unsigned int ivar, unsigned int jvar, const libMesh::DofMap &dof_map, std::vector< dof_id_type > &dof_indices, std::vector< dof_id_type > &neighbor_dof_indices, GlobalDataKey, const std::set< TagID > &tags)
	Adds three neighboring element matrices for ivar rows and jvar columns to the global Jacobian matrix.
void	cacheJacobian (GlobalDataKey)
	Takes the values that are currently in _sub_Kee and appends them to the cached values.
void	cacheJacobianNonlocal (GlobalDataKey)
	Takes the values that are currently in _sub_Keg and appends them to the cached values.
void	cacheJacobianNeighbor (GlobalDataKey)
	Takes the values that are currently in the neighbor Dense Matrices and appends them to the cached values.
void	addCachedJacobian (GlobalDataKey)
	Adds the values that have been cached by calling cacheJacobian() and or cacheJacobianNeighbor() to the jacobian matrix.
void	setCachedJacobian (GlobalDataKey)
	Sets previously-cached Jacobian values via SparseMatrix::set() calls.
void	zeroCachedJacobian (GlobalDataKey)
	Zero out previously-cached Jacobian rows.
DenseVector< Number > &	residualBlock (unsigned int var_num, LocalDataKey, TagID tag_id)
	Get local residual block for a variable and a tag.
DenseVector< Number > &	residualBlockNeighbor (unsigned int var_num, LocalDataKey, TagID tag_id)
	Get local neighbor residual block for a variable and a tag.
DenseVector< Number > &	residualBlockLower (unsigned int var_num, LocalDataKey, TagID tag_id)
	Get residual block for lower.
DenseMatrix< Number > &	jacobianBlock (unsigned int ivar, unsigned int jvar, LocalDataKey, TagID tag)
	Get local Jacobian block for a pair of variables and a tag.
DenseMatrix< Number > &	jacobianBlockNonlocal (unsigned int ivar, unsigned int jvar, LocalDataKey, TagID tag)
	Get local Jacobian block from non-local contribution for a pair of variables and a tag.
DenseMatrix< Number > &	jacobianBlockNeighbor (Moose::DGJacobianType type, unsigned int ivar, unsigned int jvar, LocalDataKey, TagID tag)
	Get local Jacobian block of a DG Jacobian type for a pair of variables and a tag.
DenseMatrix< Number > &	jacobianBlockMortar (Moose::ConstraintJacobianType type, unsigned int ivar, unsigned int jvar, LocalDataKey, TagID tag)
	Returns the jacobian block for the given mortar Jacobian type.
void	cacheResidualNodes (const DenseVector< Number > &res, const std::vector< dof_id_type > &dof_index, LocalDataKey, TagID tag)
	Lets an external class cache residual at a set of nodes.
void	cacheJacobian (numeric_index_type i, numeric_index_type j, Real value, LocalDataKey, TagID tag)
	Caches the Jacobian entry 'value', to eventually be added/set in the (i,j) location of the matrix.
void	cacheJacobian (numeric_index_type i, numeric_index_type j, Real value, LocalDataKey, const std::set< TagID > &tags)
	Caches the Jacobian entry 'value', to eventually be added/set in the (i,j) location of the matrices in corresponding to tags.
void	cacheJacobianBlock (const DenseMatrix< Number > &jac_block, const std::vector< dof_id_type > &idof_indices, const std::vector< dof_id_type > &jdof_indices, Real scaling_factor, LocalDataKey, const std::set< TagID > &tags)
	Cache a local Jacobian block with the provided rows (idof_indices) and columns (jdof_indices) for eventual accumulation into the global matrices specified by tags.
template<typename Residuals , typename Indices >
void	cacheResiduals (const Residuals &residuals, const Indices &row_indices, Real scaling_factor, LocalDataKey, const std::set< TagID > &vector_tags)
	Process the supplied residual values.
template<typename Residuals , typename Indices >
void	cacheJacobian (const Residuals &residuals, const Indices &row_indices, Real scaling_factor, LocalDataKey, const std::set< TagID > &matrix_tags)
	Process the derivatives() data of a vector of ADReals.
template<typename Residuals , typename Indices >
void	cacheResidualsWithoutConstraints (const Residuals &residuals, const Indices &row_indices, Real scaling_factor, LocalDataKey, const std::set< TagID > &vector_tags)
	Process the supplied residual values.
template<typename Residuals , typename Indices >
void	cacheJacobianWithoutConstraints (const Residuals &residuals, const Indices &row_indices, Real scaling_factor, LocalDataKey, const std::set< TagID > &matrix_tags)
	Process the derivatives() data of a vector of ADReals.
std::vector< std::pair< MooseVariableFieldBase *, MooseVariableFieldBase * > > &	couplingEntries ()
const std::vector< std::pair< MooseVariableFieldBase *, MooseVariableFieldBase * > > &	couplingEntries () const
std::vector< std::pair< MooseVariableFieldBase *, MooseVariableFieldBase * > > &	nonlocalCouplingEntries ()
const std::vector< std::pair< MooseVariableFieldBase *, MooseVariableScalar * > > &	fieldScalarCouplingEntries () const
const std::vector< std::pair< MooseVariableScalar *, MooseVariableFieldBase * > > &	scalarFieldCouplingEntries () const
const VariablePhiValue &	phi () const
template<typename T >
const ADTemplateVariablePhiGradient< T > &	adGradPhi (const MooseVariableFE< T > &v) const
const VariablePhiValue &	phi (const MooseVariableField< Real > &) const
const VariablePhiGradient &	gradPhi () const
const VariablePhiGradient &	gradPhi (const MooseVariableField< Real > &) const
const VariablePhiSecond &	secondPhi () const
const VariablePhiSecond &	secondPhi (const MooseVariableField< Real > &) const
const VariablePhiValue &	phiFace () const
const VariablePhiValue &	phiFace (const MooseVariableField< Real > &) const
const VariablePhiGradient &	gradPhiFace () const
const VariablePhiGradient &	gradPhiFace (const MooseVariableField< Real > &) const
const VariablePhiSecond &	secondPhiFace (const MooseVariableField< Real > &) const
const VariablePhiValue &	phiNeighbor (const MooseVariableField< Real > &) const
const VariablePhiGradient &	gradPhiNeighbor (const MooseVariableField< Real > &) const
const VariablePhiSecond &	secondPhiNeighbor (const MooseVariableField< Real > &) const
const VariablePhiValue &	phiFaceNeighbor (const MooseVariableField< Real > &) const
const VariablePhiGradient &	gradPhiFaceNeighbor (const MooseVariableField< Real > &) const
const VariablePhiSecond &	secondPhiFaceNeighbor (const MooseVariableField< Real > &) const
const VectorVariablePhiValue &	phi (const MooseVariableField< RealVectorValue > &) const
const VectorVariablePhiGradient &	gradPhi (const MooseVariableField< RealVectorValue > &) const
const VectorVariablePhiSecond &	secondPhi (const MooseVariableField< RealVectorValue > &) const
const VectorVariablePhiCurl &	curlPhi (const MooseVariableField< RealVectorValue > &) const
const VectorVariablePhiDivergence &	divPhi (const MooseVariableField< RealVectorValue > &) const
const VectorVariablePhiValue &	phiFace (const MooseVariableField< RealVectorValue > &) const
const VectorVariablePhiGradient &	gradPhiFace (const MooseVariableField< RealVectorValue > &) const
const VectorVariablePhiSecond &	secondPhiFace (const MooseVariableField< RealVectorValue > &) const
const VectorVariablePhiCurl &	curlPhiFace (const MooseVariableField< RealVectorValue > &) const
const VectorVariablePhiDivergence &	divPhiFace (const MooseVariableField< RealVectorValue > &) const
const VectorVariablePhiValue &	phiNeighbor (const MooseVariableField< RealVectorValue > &) const
const VectorVariablePhiGradient &	gradPhiNeighbor (const MooseVariableField< RealVectorValue > &) const
const VectorVariablePhiSecond &	secondPhiNeighbor (const MooseVariableField< RealVectorValue > &) const
const VectorVariablePhiCurl &	curlPhiNeighbor (const MooseVariableField< RealVectorValue > &) const
const VectorVariablePhiDivergence &	divPhiNeighbor (const MooseVariableField< RealVectorValue > &) const
const VectorVariablePhiValue &	phiFaceNeighbor (const MooseVariableField< RealVectorValue > &) const
const VectorVariablePhiGradient &	gradPhiFaceNeighbor (const MooseVariableField< RealVectorValue > &) const
const VectorVariablePhiSecond &	secondPhiFaceNeighbor (const MooseVariableField< RealVectorValue > &) const
const VectorVariablePhiCurl &	curlPhiFaceNeighbor (const MooseVariableField< RealVectorValue > &) const
const VectorVariablePhiDivergence &	divPhiFaceNeighbor (const MooseVariableField< RealVectorValue > &) const
VariablePhiValue &	phi (const MooseVariableField< Real > &)
VariablePhiGradient &	gradPhi (const MooseVariableField< Real > &)
VariablePhiSecond &	secondPhi (const MooseVariableField< Real > &)
VariablePhiValue &	phiFace (const MooseVariableField< Real > &)
VariablePhiGradient &	gradPhiFace (const MooseVariableField< Real > &)
VariablePhiSecond &	secondPhiFace (const MooseVariableField< Real > &)
VariablePhiValue &	phiNeighbor (const MooseVariableField< Real > &)
VariablePhiGradient &	gradPhiNeighbor (const MooseVariableField< Real > &)
VariablePhiSecond &	secondPhiNeighbor (const MooseVariableField< Real > &)
VariablePhiValue &	phiFaceNeighbor (const MooseVariableField< Real > &)
VariablePhiGradient &	gradPhiFaceNeighbor (const MooseVariableField< Real > &)
VariablePhiSecond &	secondPhiFaceNeighbor (const MooseVariableField< Real > &)
VectorVariablePhiValue &	phi (const MooseVariableField< RealVectorValue > &)
VectorVariablePhiGradient &	gradPhi (const MooseVariableField< RealVectorValue > &)
VectorVariablePhiSecond &	secondPhi (const MooseVariableField< RealVectorValue > &)
VectorVariablePhiCurl &	curlPhi (const MooseVariableField< RealVectorValue > &)
VectorVariablePhiDivergence &	divPhi (const MooseVariableField< RealVectorValue > &)
VectorVariablePhiValue &	phiFace (const MooseVariableField< RealVectorValue > &)
VectorVariablePhiGradient &	gradPhiFace (const MooseVariableField< RealVectorValue > &)
VectorVariablePhiSecond &	secondPhiFace (const MooseVariableField< RealVectorValue > &)
VectorVariablePhiCurl &	curlPhiFace (const MooseVariableField< RealVectorValue > &)
VectorVariablePhiDivergence &	divPhiFace (const MooseVariableField< RealVectorValue > &)
VectorVariablePhiValue &	phiNeighbor (const MooseVariableField< RealVectorValue > &)
VectorVariablePhiGradient &	gradPhiNeighbor (const MooseVariableField< RealVectorValue > &)
VectorVariablePhiSecond &	secondPhiNeighbor (const MooseVariableField< RealVectorValue > &)
VectorVariablePhiCurl &	curlPhiNeighbor (const MooseVariableField< RealVectorValue > &)
VectorVariablePhiDivergence &	divPhiNeighbor (const MooseVariableField< RealVectorValue > &)
VectorVariablePhiValue &	phiFaceNeighbor (const MooseVariableField< RealVectorValue > &)
VectorVariablePhiGradient &	gradPhiFaceNeighbor (const MooseVariableField< RealVectorValue > &)
VectorVariablePhiSecond &	secondPhiFaceNeighbor (const MooseVariableField< RealVectorValue > &)
VectorVariablePhiCurl &	curlPhiFaceNeighbor (const MooseVariableField< RealVectorValue > &)
VectorVariablePhiDivergence &	divPhiFaceNeighbor (const MooseVariableField< RealVectorValue > &)
VariablePhiValue &	phi (const MooseVariableField< RealEigenVector > &)
VariablePhiGradient &	gradPhi (const MooseVariableField< RealEigenVector > &)
VariablePhiSecond &	secondPhi (const MooseVariableField< RealEigenVector > &)
VariablePhiValue &	phiFace (const MooseVariableField< RealEigenVector > &)
VariablePhiGradient &	gradPhiFace (const MooseVariableField< RealEigenVector > &)
VariablePhiSecond &	secondPhiFace (const MooseVariableField< RealEigenVector > &)
VariablePhiValue &	phiNeighbor (const MooseVariableField< RealEigenVector > &)
VariablePhiGradient &	gradPhiNeighbor (const MooseVariableField< RealEigenVector > &)
VariablePhiSecond &	secondPhiNeighbor (const MooseVariableField< RealEigenVector > &)
VariablePhiValue &	phiFaceNeighbor (const MooseVariableField< RealEigenVector > &)
VariablePhiGradient &	gradPhiFaceNeighbor (const MooseVariableField< RealEigenVector > &)
VariablePhiSecond &	secondPhiFaceNeighbor (const MooseVariableField< RealEigenVector > &)
template<typename OutputType >
const OutputTools< OutputType >::VariablePhiValue &	fePhi (FEType type) const
template<typename OutputType >
const OutputTools< OutputType >::VariablePhiGradient &	feGradPhi (FEType type) const
template<typename OutputType >
const ADTemplateVariablePhiGradient< OutputType > &	feADGradPhi (FEType type) const
template<typename OutputType >
const OutputTools< OutputType >::VariablePhiSecond &	feSecondPhi (FEType type) const
template<typename OutputType >
const OutputTools< OutputType >::VariablePhiValue &	fePhiLower (FEType type) const
template<typename OutputType >
const OutputTools< OutputType >::VariablePhiValue &	feDualPhiLower (FEType type) const
template<typename OutputType >
const OutputTools< OutputType >::VariablePhiGradient &	feGradPhiLower (FEType type) const
template<typename OutputType >
const OutputTools< OutputType >::VariablePhiGradient &	feGradDualPhiLower (FEType type) const
template<typename OutputType >
const OutputTools< OutputType >::VariablePhiValue &	fePhiFace (FEType type) const
template<typename OutputType >
const OutputTools< OutputType >::VariablePhiGradient &	feGradPhiFace (FEType type) const
template<typename OutputType >
const ADTemplateVariablePhiGradient< OutputType > &	feADGradPhiFace (FEType type) const
void	needADGradPhiFace () const
	Request that face reinitialization compute the AD shape function gradients.
template<typename OutputType >
const OutputTools< OutputType >::VariablePhiSecond &	feSecondPhiFace (FEType type) const
template<typename OutputType >
const OutputTools< OutputType >::VariablePhiValue &	fePhiNeighbor (FEType type) const
template<typename OutputType >
const OutputTools< OutputType >::VariablePhiGradient &	feGradPhiNeighbor (FEType type) const
template<typename OutputType >
const OutputTools< OutputType >::VariablePhiSecond &	feSecondPhiNeighbor (FEType type) const
template<typename OutputType >
const OutputTools< OutputType >::VariablePhiValue &	fePhiFaceNeighbor (FEType type) const
template<typename OutputType >
const OutputTools< OutputType >::VariablePhiGradient &	feGradPhiFaceNeighbor (FEType type) const
template<typename OutputType >
const OutputTools< OutputType >::VariablePhiSecond &	feSecondPhiFaceNeighbor (FEType type) const
template<typename OutputType >
const OutputTools< OutputType >::VariablePhiCurl &	feCurlPhi (FEType type) const
template<typename OutputType >
const OutputTools< OutputType >::VariablePhiCurl &	feCurlPhiFace (FEType type) const
template<typename OutputType >
const OutputTools< OutputType >::VariablePhiCurl &	feCurlPhiNeighbor (FEType type) const
template<typename OutputType >
const OutputTools< OutputType >::VariablePhiCurl &	feCurlPhiFaceNeighbor (FEType type) const
template<typename OutputType >
const OutputTools< OutputType >::VariablePhiDivergence &	feDivPhi (FEType type) const
template<typename OutputType >
const OutputTools< OutputType >::VariablePhiDivergence &	feDivPhiFace (FEType type) const
template<typename OutputType >
const OutputTools< OutputType >::VariablePhiDivergence &	feDivPhiNeighbor (FEType type) const
template<typename OutputType >
const OutputTools< OutputType >::VariablePhiDivergence &	feDivPhiFaceNeighbor (FEType type) const
Real	elementVolume (const Elem *elem) const
	On-demand computation of volume element accounting for RZ/RSpherical.
void	setXFEM (std::shared_ptr< XFEMInterface > xfem)
	Set the pointer to the XFEM controller object.
void	assignDisplacements (std::vector< std::pair< unsigned int, unsigned short > > &&disp_numbers_and_directions)
	Assign the displacement numbers and directions.
void	saveLocalArrayResidual (DenseVector< Number > &re, unsigned int i, unsigned int ntest, const RealEigenVector &v) const
	Helper function for assembling residual contriubutions on local quadrature points for an array kernel, bc, etc.
void	saveLocalADArray (std::vector< ADReal > &re, unsigned int i, unsigned int ntest, const ADRealEigenVector &v) const
void	saveDiagLocalArrayJacobian (DenseMatrix< Number > &ke, unsigned int i, unsigned int ntest, unsigned int j, unsigned int nphi, unsigned int ivar, const RealEigenVector &v) const
	Helper function for assembling diagonal Jacobian contriubutions on local quadrature points for an array kernel, bc, etc.
void	saveFullLocalArrayJacobian (DenseMatrix< Number > &ke, unsigned int i, unsigned int ntest, unsigned int j, unsigned int nphi, unsigned int ivar, unsigned int jvar, const RealEigenMatrix &v) const
	Helper function for assembling full Jacobian contriubutions on local quadrature points for an array kernel, bc, etc.
DenseVector< Real >	getJacobianDiagonal (const DenseMatrix< Number > &ke)
const libMesh::QBase *	attachQRuleElem (unsigned int dim, FEBase &fe)
	Attaches the current elem/volume quadrature rule to the given fe.
const libMesh::QBase *	attachQRuleFace (unsigned int dim, FEBase &fe)
	Attaches the current face/area quadrature rule to the given fe.
void	modifyArbitraryWeights (const std::vector< Real > &weights)
	Modify the weights when using the arbitrary quadrature rule.
bool	computingResidual () const
bool	computingJacobian () const
bool	computingResidualAndJacobian () const
const Elem *const &	msmElem () const
void	preparePRefinement ()
	Prepare helper FEs for p-refinement.
void	setCurrentLowerDElem (const Elem *const lower_d_elem)
	Set the current lower dimensional element.
template<>
const ADTemplateVariablePhiGradient< RealVectorValue > &	feADGradPhi (FEType type) const
template<>
const ADTemplateVariablePhiGradient< RealVectorValue > &	feADGradPhiFace (FEType type) const
template<>
const OutputTools< VectorValue< Real > >::VariablePhiValue &	fePhi (FEType type) const
template<>
const OutputTools< VectorValue< Real > >::VariablePhiGradient &	feGradPhi (FEType type) const
template<>
const OutputTools< VectorValue< Real > >::VariablePhiSecond &	feSecondPhi (FEType type) const
template<>
const OutputTools< VectorValue< Real > >::VariablePhiValue &	fePhiLower (FEType type) const
template<>
const OutputTools< VectorValue< Real > >::VariablePhiValue &	feDualPhiLower (FEType type) const
template<>
const OutputTools< VectorValue< Real > >::VariablePhiGradient &	feGradPhiLower (FEType type) const
template<>
const OutputTools< VectorValue< Real > >::VariablePhiGradient &	feGradDualPhiLower (FEType type) const
template<>
const OutputTools< VectorValue< Real > >::VariablePhiValue &	fePhiFace (FEType type) const
template<>
const OutputTools< VectorValue< Real > >::VariablePhiGradient &	feGradPhiFace (FEType type) const
template<>
const OutputTools< VectorValue< Real > >::VariablePhiSecond &	feSecondPhiFace (FEType type) const
template<>
const OutputTools< VectorValue< Real > >::VariablePhiValue &	fePhiNeighbor (FEType type) const
template<>
const OutputTools< VectorValue< Real > >::VariablePhiGradient &	feGradPhiNeighbor (FEType type) const
template<>
const OutputTools< VectorValue< Real > >::VariablePhiSecond &	feSecondPhiNeighbor (FEType type) const
template<>
const OutputTools< VectorValue< Real > >::VariablePhiValue &	fePhiFaceNeighbor (FEType type) const
template<>
const OutputTools< VectorValue< Real > >::VariablePhiGradient &	feGradPhiFaceNeighbor (FEType type) const
template<>
const OutputTools< VectorValue< Real > >::VariablePhiSecond &	feSecondPhiFaceNeighbor (FEType type) const
template<>
const OutputTools< VectorValue< Real > >::VariablePhiCurl &	feCurlPhi (FEType type) const
template<>
const OutputTools< VectorValue< Real > >::VariablePhiCurl &	feCurlPhiFace (FEType type) const
template<>
const OutputTools< VectorValue< Real > >::VariablePhiCurl &	feCurlPhiNeighbor (FEType type) const
template<>
const OutputTools< VectorValue< Real > >::VariablePhiCurl &	feCurlPhiFaceNeighbor (FEType type) const
template<>
const OutputTools< VectorValue< Real > >::VariablePhiDivergence &	feDivPhi (FEType type) const
template<>
const OutputTools< VectorValue< Real > >::VariablePhiDivergence &	feDivPhiFace (FEType type) const
template<>
const OutputTools< VectorValue< Real > >::VariablePhiDivergence &	feDivPhiNeighbor (FEType type) const
template<>
const OutputTools< VectorValue< Real > >::VariablePhiDivergence &	feDivPhiFaceNeighbor (FEType type) const
template<>
const ADTemplateVariablePhiGradient< RealVectorValue > &	adGradPhi (const MooseVariableFE< RealVectorValue > &v) const
template<typename OutputType >
void	computeGradPhiAD (const Elem *elem, unsigned int n_qp, ADTemplateVariablePhiGradient< OutputType > &grad_phi, FEGenericBase< OutputType > *fe)
template<typename Points , typename Coords >
void	setCoordinateTransformation (const QBase *qrule, const Points &q_points, Coords &coord, SubdomainID sub_id)
template<>
const OutputTools< VectorValue< Real > >::VariablePhiValue &	fePhi (FEType type) const
template<>
const OutputTools< VectorValue< Real > >::VariablePhiGradient &	feGradPhi (FEType type) const
template<>
const OutputTools< VectorValue< Real > >::VariablePhiSecond &	feSecondPhi (FEType type) const
template<>
const OutputTools< VectorValue< Real > >::VariablePhiValue &	fePhiLower (FEType type) const
template<>
const OutputTools< VectorValue< Real > >::VariablePhiValue &	feDualPhiLower (FEType type) const
template<>
const OutputTools< VectorValue< Real > >::VariablePhiGradient &	feGradPhiLower (FEType type) const
template<>
const OutputTools< VectorValue< Real > >::VariablePhiGradient &	feGradDualPhiLower (FEType type) const
template<>
const OutputTools< VectorValue< Real > >::VariablePhiValue &	fePhiFace (FEType type) const
template<>
const OutputTools< VectorValue< Real > >::VariablePhiGradient &	feGradPhiFace (FEType type) const
template<>
const OutputTools< VectorValue< Real > >::VariablePhiSecond &	feSecondPhiFace (FEType type) const
template<>
const OutputTools< VectorValue< Real > >::VariablePhiValue &	fePhiNeighbor (FEType type) const
template<>
const OutputTools< VectorValue< Real > >::VariablePhiGradient &	feGradPhiNeighbor (FEType type) const
template<>
const OutputTools< VectorValue< Real > >::VariablePhiSecond &	feSecondPhiNeighbor (FEType type) const
template<>
const OutputTools< VectorValue< Real > >::VariablePhiValue &	fePhiFaceNeighbor (FEType type) const
template<>
const OutputTools< VectorValue< Real > >::VariablePhiGradient &	feGradPhiFaceNeighbor (FEType type) const
template<>
const OutputTools< VectorValue< Real > >::VariablePhiSecond &	feSecondPhiFaceNeighbor (FEType type) const
template<>
const OutputTools< VectorValue< Real > >::VariablePhiCurl &	feCurlPhi (FEType type) const
template<>
const OutputTools< VectorValue< Real > >::VariablePhiCurl &	feCurlPhiFace (FEType type) const
template<>
const OutputTools< VectorValue< Real > >::VariablePhiCurl &	feCurlPhiNeighbor (FEType type) const
template<>
const OutputTools< VectorValue< Real > >::VariablePhiCurl &	feCurlPhiFaceNeighbor (FEType type) const
template<>
const OutputTools< VectorValue< Real > >::VariablePhiDivergence &	feDivPhi (FEType type) const
template<>
const OutputTools< VectorValue< Real > >::VariablePhiDivergence &	feDivPhiFace (FEType type) const
template<>
const OutputTools< VectorValue< Real > >::VariablePhiDivergence &	feDivPhiNeighbor (FEType type) const
template<>
const OutputTools< VectorValue< Real > >::VariablePhiDivergence &	feDivPhiFaceNeighbor (FEType type) const
template<>
const MooseArray< Moose::GenericType< Point, false > > &	genericQPoints () const
template<>
const MooseArray< Moose::GenericType< Point, true > > &	genericQPoints () const

Static Public Member Functions
template<typename T >
static const T *const &	constify_ref (T *const &inref)
	Workaround for C++ compilers thinking they can't just cast a const-reference-to-pointer to const-reference-to-const-pointer.

Protected Attributes
const Elem *	_current_elem
	The current "element" we are currently on.
SubdomainID	_current_subdomain_id
	The current subdomain ID.
BoundaryID	_current_boundary_id
	The current boundary ID.
Real	_current_elem_volume
	Volume of the current element.
unsigned int	_current_side
	The current side of the selected element (valid only when working with sides)
const Elem *	_current_side_elem
	The current "element" making up the side we are currently on.
Real	_current_side_volume
	Volume of the current side element.
const Elem *	_current_neighbor_elem
	The current neighbor "element".
SubdomainID	_current_neighbor_subdomain_id
	The current neighbor subdomain ID.
unsigned int	_current_neighbor_side
	The current side of the selected neighboring element (valid only when working with sides)
const Elem *	_current_neighbor_side_elem
	The current side element of the ncurrent neighbor element.
bool	_need_neighbor_elem_volume
	true is apps need to compute neighbor element volume
Real	_current_neighbor_volume
	Volume of the current neighbor.
const Node *	_current_node
	The current node we are working with.
const Node *	_current_neighbor_node
	The current neighboring node we are working with.
bool	_current_elem_volume_computed
	Boolean to indicate whether current element volumes has been computed.
bool	_current_side_volume_computed
	Boolean to indicate whether current element side volumes has been computed.
const Elem *	_current_lower_d_elem
	The current lower dimensional element.
const Elem *	_current_neighbor_lower_d_elem
	The current neighboring lower dimensional element.
bool	_need_lower_d_elem_volume
	Whether we need to compute the lower dimensional element volume.
Real	_current_lower_d_elem_volume
	The current lower dimensional element volume.
bool	_need_neighbor_lower_d_elem_volume
	Whether we need to compute the neighboring lower dimensional element volume.
Real	_current_neighbor_lower_d_elem_volume
	The current neighboring lower dimensional element volume.
bool	_need_dual
	Whether dual shape functions need to be computed for mortar constraints.
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.
std::vector< std::vector< DenseVector< Number > > >	_sub_Re
std::vector< std::vector< DenseVector< Number > > >	_sub_Rn
std::vector< std::vector< DenseVector< Number > > >	_sub_Rl
	residual contributions for each variable from the lower dimensional element
DenseVector< Number >	_tmp_Re
	auxiliary vector for scaling residuals (optimization to avoid expensive construction/destruction)
std::vector< std::vector< std::vector< DenseMatrix< Number > > > >	_sub_Kee
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>
std::vector< std::vector< std::vector< DenseMatrix< Number > > > >	_sub_Kne
	jacobian contributions from the neighbor and element <Tag, ivar, jvar>
std::vector< std::vector< std::vector< DenseMatrix< Number > > > >	_sub_Knn
	jacobian contributions from the neighbor <Tag, ivar, jvar>
std::vector< std::vector< std::vector< DenseMatrix< Number > > > >	_sub_Kll
	dlower/dlower
std::vector< std::vector< std::vector< DenseMatrix< Number > > > >	_sub_Kle
	dlower/dsecondary (or dlower/delement)
std::vector< std::vector< std::vector< DenseMatrix< Number > > > >	_sub_Kln
	dlower/dprimary (or dlower/dneighbor)
std::vector< std::vector< std::vector< DenseMatrix< Number > > > >	_sub_Kel
	dsecondary/dlower (or delement/dlower)
std::vector< std::vector< std::vector< DenseMatrix< Number > > > >	_sub_Knl
	dprimary/dlower (or dneighbor/dlower)
DenseMatrix< Number >	_tmp_Ke
	auxiliary matrix for scaling jacobians (optimization to avoid expensive construction/destruction)
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
VectorVariablePhiDivergence	_vector_div_phi
VectorVariablePhiValue	_vector_phi_face
VectorVariablePhiGradient	_vector_grad_phi_face
VectorVariablePhiSecond	_vector_second_phi_face
VectorVariablePhiCurl	_vector_curl_phi_face
VectorVariablePhiDivergence	_vector_div_phi_face
VectorVariablePhiValue	_vector_phi_neighbor
VectorVariablePhiGradient	_vector_grad_phi_neighbor
VectorVariablePhiSecond	_vector_second_phi_neighbor
VectorVariablePhiCurl	_vector_curl_phi_neighbor
VectorVariablePhiDivergence	_vector_div_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
VectorVariablePhiDivergence	_vector_div_phi_face_neighbor
std::map< FEType, std::unique_ptr< FEShapeData > >	_fe_shape_data
	Shape function values, gradients, second derivatives for each FE type.
std::map< FEType, std::unique_ptr< FEShapeData > >	_fe_shape_data_face
std::map< FEType, std::unique_ptr< FEShapeData > >	_fe_shape_data_neighbor
std::map< FEType, std::unique_ptr< FEShapeData > >	_fe_shape_data_face_neighbor
std::map< FEType, std::unique_ptr< FEShapeData > >	_fe_shape_data_lower
std::map< FEType, std::unique_ptr< FEShapeData > >	_fe_shape_data_dual_lower
std::map< FEType, std::unique_ptr< VectorFEShapeData > >	_vector_fe_shape_data
	Shape function values, gradients, second derivatives for each vector FE type.
std::map< FEType, std::unique_ptr< VectorFEShapeData > >	_vector_fe_shape_data_face
std::map< FEType, std::unique_ptr< VectorFEShapeData > >	_vector_fe_shape_data_neighbor
std::map< FEType, std::unique_ptr< VectorFEShapeData > >	_vector_fe_shape_data_face_neighbor
std::map< FEType, std::unique_ptr< VectorFEShapeData > >	_vector_fe_shape_data_lower
std::map< FEType, std::unique_ptr< VectorFEShapeData > >	_vector_fe_shape_data_dual_lower
std::map< FEType, ADTemplateVariablePhiGradient< Real > >	_ad_grad_phi_data
std::map< FEType, ADTemplateVariablePhiGradient< RealVectorValue > >	_ad_vector_grad_phi_data
std::map< FEType, ADTemplateVariablePhiGradient< Real > >	_ad_grad_phi_data_face
std::map< FEType, ADTemplateVariablePhiGradient< RealVectorValue > >	_ad_vector_grad_phi_data_face
bool	_need_ad_grad_phi_face = false
	Whether any object needs the AD face shape function gradients.
const std::vector< VectorTag > &	_residual_vector_tags
	The residual vector tags that Assembly could possibly contribute to.
std::vector< std::vector< Real > >	_cached_residual_values
	Values cached by calling cacheResidual() (the first vector is for TIME vs NONTIME)
std::vector< std::vector< dof_id_type > >	_cached_residual_rows
	Where the cached values should go (the first vector is for TIME vs NONTIME)
unsigned int	_max_cached_residuals
std::vector< std::vector< Real > >	_cached_jacobian_values
	Values cached by calling cacheJacobian()
std::vector< std::vector< dof_id_type > >	_cached_jacobian_rows
	Row where the corresponding cached value should go.
std::vector< std::vector< dof_id_type > >	_cached_jacobian_cols
	Column where the corresponding cached value should go.
unsigned int	_max_cached_jacobians
bool	_block_diagonal_matrix
	Will be true if our preconditioning matrix is a block-diagonal matrix. Which means that we can take some shortcuts.
std::vector< bool >	_component_block_diagonal
	An flag array Indiced by variable index to show if there is no component-wise coupling for the variable.
std::vector< dof_id_type >	_temp_dof_indices
	Temporary work vector to keep from reallocating it.
std::vector< Point >	_temp_reference_points
	Temporary work data for reinitAtPhysical()
std::vector< VectorValue< ADReal > >	_ad_dxyzdxi_map
	AD quantities.
std::vector< VectorValue< ADReal > >	_ad_dxyzdeta_map
std::vector< VectorValue< ADReal > >	_ad_dxyzdzeta_map
std::vector< VectorValue< ADReal > >	_ad_d2xyzdxi2_map
std::vector< VectorValue< ADReal > >	_ad_d2xyzdxideta_map
std::vector< VectorValue< ADReal > >	_ad_d2xyzdeta2_map
std::vector< ADReal >	_ad_jac
MooseArray< ADReal >	_ad_JxW
MooseArray< VectorValue< ADReal > >	_ad_q_points
std::vector< ADReal >	_ad_dxidx_map
std::vector< ADReal >	_ad_dxidy_map
std::vector< ADReal >	_ad_dxidz_map
std::vector< ADReal >	_ad_detadx_map
std::vector< ADReal >	_ad_detady_map
std::vector< ADReal >	_ad_detadz_map
std::vector< ADReal >	_ad_dzetadx_map
std::vector< ADReal >	_ad_dzetady_map
std::vector< ADReal >	_ad_dzetadz_map
MooseArray< ADReal >	_ad_JxW_face
MooseArray< VectorValue< ADReal > >	_ad_normals
MooseArray< VectorValue< ADReal > >	_ad_q_points_face
MooseArray< Real >	_curvatures
MooseArray< ADReal >	_ad_curvatures
std::vector< std::pair< unsigned int, unsigned short > >	_disp_numbers_and_directions
	Container of displacement numbers and directions.
bool	_calculate_xyz
bool	_calculate_face_xyz
bool	_calculate_curvatures
bool	_calculate_ad_coord
	Whether to calculate coord with AD.
std::set< FEType >	_need_second_derivative
std::set< FEType >	_need_second_derivative_neighbor
std::set< FEType >	_need_curl
std::set< FEType >	_need_div
std::set< FEType >	_need_face_div
std::set< FEType >	_need_neighbor_div
std::set< FEType >	_need_face_neighbor_div
libMesh::ElemSideBuilder	_current_side_elem_builder
	In place side element builder for _current_side_elem.
libMesh::ElemSideBuilder	_current_neighbor_side_elem_builder
	In place side element builder for _current_neighbor_side_elem.
libMesh::ElemSideBuilder	_compute_face_map_side_elem_builder
	In place side element builder for computeFaceMap()
const Elem *	_msm_elem = nullptr
DenseVector< Number >	_element_vector
	A working vector to avoid repeated heap allocations when caching residuals that must have libMesh-level constraints (hanging nodes, periodic bcs) applied to them.
DenseMatrix< Number >	_element_matrix
	A working matrix to avoid repeated heap allocations when caching Jacobians that must have libMesh-level constraints (hanging nodes, periodic bcs) applied to them.
std::vector< dof_id_type >	_row_indices
	Working vectors to avoid repeated heap allocations when caching residuals/Jacobians that must have libMesh-level constraints (hanging nodes, periodic bcs) applied to them.
std::vector< dof_id_type >	_column_indices
bool	_prepared_for_p_refinement
	Whether helper FEs have been prepared for p-refinement.
std::vector< Point >	_current_neighbor_ref_points
	The current reference points on the neighbor element.

Private Member Functions
void	setLowerQRule (libMesh::QBase *qrule, unsigned int dim)
	Set the qrule to be used for lower dimensional integration.
void	computeADFace (const Elem &elem, const unsigned int side)
	compute AD things on an element face
void	reinitFE (const Elem *elem)
	Just an internal helper function to reinit the volume FE objects.
void	reinitFEFace (const Elem *elem, unsigned int side)
	Just an internal helper function to reinit the face FE objects.
void	computeFaceMap (const Elem &elem, const unsigned int side, const std::vector< Real > &qw)
void	reinitFEFaceNeighbor (const Elem *neighbor, const std::vector< Point > &reference_points)
void	reinitFENeighbor (const Elem *neighbor, const std::vector< Point > &reference_points)
template<typename Points , typename Coords >
void	setCoordinateTransformation (const libMesh::QBase *qrule, const Points &q_points, Coords &coord, SubdomainID sub_id)
void	computeCurrentElemVolume ()
void	computeCurrentFaceVolume ()
void	computeCurrentNeighborVolume ()
void	modifyWeightsDueToXFEM (const Elem *elem)
	Update the integration weights for XFEM partial elements.
void	modifyFaceWeightsDueToXFEM (const Elem *elem, unsigned int side=0)
	Update the face integration weights for XFEM partial elements.
template<typename OutputType >
void	computeGradPhiAD (const Elem *elem, unsigned int n_qp, ADTemplateVariablePhiGradient< OutputType > &grad_phi, libMesh::FEGenericBase< OutputType > *fe)
	compute gradient of phi possibly with derivative information with respect to nonlinear displacement variables
void	resizeADMappingObjects (unsigned int n_qp, unsigned int dim)
	resize any objects that contribute to automatic differentiation-related mapping calculations
void	computeSinglePointMapAD (const Elem *elem, const std::vector< Real > &qw, unsigned p, FEBase *fe)
	compute the finite element reference-physical mapping quantities (such as JxW) with possible dependence on nonlinear displacement variables at a single quadrature point
void	addResidual (const VectorTag &vector_tag)
	Add local residuals of all field variables for a tag onto the tag's residual vector.
void	addResidualNeighbor (const VectorTag &vector_tag)
	Add local neighbor residuals of all field variables for a tag onto the tag's residual vector.
void	addResidualLower (const VectorTag &vector_tag)
	Add local lower-dimensional block residuals of all field variables for a tag onto the tag's residual vector.
void	addResidualScalar (const VectorTag &vector_tag)
	Add residuals of all scalar variables for a tag onto the tag's residual vector.
void	clearCachedResiduals (const VectorTag &vector_tag)
	Clears all of the cached residuals for a specific vector tag.
void	cacheResidual (dof_id_type dof, Real value, TagID tag_id)
	Cache individual residual contributions.
void	cacheResidual (dof_id_type dof, Real value, const std::set< TagID > &tags)
	Cache individual residual contributions.
void	processLocalResidual (DenseVector< Number > &res_block, std::vector< dof_id_type > &dof_indices, const std::vector< Real > &scaling_factor)
	Appling scaling, constraints to the local residual block and populate the full DoF indices for array variable.
void	addResidualBlock (NumericVector< Number > &residual, DenseVector< Number > &res_block, const std::vector< dof_id_type > &dof_indices, const std::vector< Real > &scaling_factor)
	Add a local residual block to a global residual vector with proper scaling.
void	cacheResidualBlock (std::vector< Real > &cached_residual_values, std::vector< dof_id_type > &cached_residual_rows, DenseVector< Number > &res_block, const std::vector< dof_id_type > &dof_indices, const std::vector< Real > &scaling_factor)
	Push a local residual block with proper scaling into cache.
void	setResidualBlock (NumericVector< Number > &residual, DenseVector< Number > &res_block, const std::vector< dof_id_type > &dof_indices, const std::vector< Real > &scaling_factor)
	Set a local residual block to a global residual vector with proper scaling.
void	addJacobianBlock (libMesh::SparseMatrix< Number > &jacobian, DenseMatrix< Number > &jac_block, const MooseVariableBase &ivar, const MooseVariableBase &jvar, const std::vector< dof_id_type > &idof_indices, const std::vector< dof_id_type > &jdof_indices)
	Add a local Jacobian block to a global Jacobian with proper scaling.
void	cacheJacobianBlock (const DenseMatrix< Number > &jac_block, const MooseVariableBase &ivar, const MooseVariableBase &jvar, const std::vector< dof_id_type > &idof_indices, const std::vector< dof_id_type > &jdof_indices, TagID tag)
	Push a local Jacobian block with proper scaling into cache for a certain tag.
void	cacheJacobianBlockNonzero (const DenseMatrix< Number > &jac_block, const MooseVariableBase &ivar, const MooseVariableBase &jvar, const std::vector< dof_id_type > &idof_indices, const std::vector< dof_id_type > &jdof_indices, TagID tag)
	Push non-zeros of a local Jacobian block with proper scaling into cache for a certain tag.
void	addJacobianCoupledVarPair (const MooseVariableBase &ivar, const MooseVariableBase &jvar)
	Adds element matrices for ivar rows and jvar columns to the global Jacobian matrices.
void	cacheJacobianCoupledVarPair (const MooseVariableBase &ivar, const MooseVariableBase &jvar)
	Caches element matrix for ivar rows and jvar columns.
void	clearCachedJacobian ()
	Clear any currently cached jacobians.
void	buildFE (FEType type) const
	Build FEs with a type.
void	buildFaceFE (FEType type) const
	Build FEs for a face with a type.
void	buildNeighborFE (FEType type) const
	Build FEs for a neighbor with a type.
void	buildFaceNeighborFE (FEType type) const
	Build FEs for a neighbor face with a type.
void	buildLowerDFE (FEType type) const
	Build FEs for a lower dimensional element with a type.
void	buildLowerDDualFE (FEType type) const
void	buildVectorFE (FEType type) const
	Build Vector FEs with a type.
void	buildVectorFaceFE (FEType type) const
	Build Vector FEs for a face with a type.
void	buildVectorNeighborFE (FEType type) const
	Build Vector FEs for a neighbor with a type.
void	buildVectorFaceNeighborFE (FEType type) const
	Build Vector FEs for a neighbor face with a type.
void	buildVectorLowerDFE (FEType type) const
	Build Vector FEs for a lower dimensional element with a type.
void	buildVectorDualLowerDFE (FEType type) const
void	jacobianBlockUsed (TagID tag, unsigned int ivar, unsigned int jvar, bool used)
	Sets whether or not Jacobian coupling between ivar and jvar is used to the value used.
char	jacobianBlockUsed (TagID tag, unsigned int ivar, unsigned int jvar) const
	Return a flag to indicate if a particular coupling Jacobian block between ivar and jvar is used.
void	jacobianBlockNeighborUsed (TagID tag, unsigned int ivar, unsigned int jvar, bool used)
	Sets whether or not neighbor Jacobian coupling between ivar and jvar is used to the value used.
char	jacobianBlockNeighborUsed (TagID tag, unsigned int ivar, unsigned int jvar) const
	Return a flag to indicate if a particular coupling neighbor Jacobian block between ivar and jvar is used.
void	jacobianBlockLowerUsed (TagID tag, unsigned int ivar, unsigned int jvar, bool used)
	Sets whether or not lower Jacobian coupling between ivar and jvar is used to the value used.
char	jacobianBlockLowerUsed (TagID tag, unsigned int ivar, unsigned int jvar) const
	Return a flag to indicate if a particular coupling lower Jacobian block between ivar and jvar is used.
void	jacobianBlockNonlocalUsed (TagID tag, unsigned int ivar, unsigned int jvar, bool used)
	Sets whether or not nonlocal Jacobian coupling between ivar and jvar is used to the value used.
char	jacobianBlockNonlocalUsed (TagID tag, unsigned int ivar, unsigned int jvar) const
	Return a flag to indicate if a particular coupling nonlocal Jacobian block between ivar and jvar is used.
void	helpersRequestData ()
	request phi, dphi, xyz, JxW, etc.
libMesh::QBase *	qruleFace (const Elem *elem, unsigned int side)
	This is an abstraction over the internal qrules function.
ArbitraryQuadrature *	qruleArbitraryFace (const Elem *elem, unsigned int side)
template<typename T >
T *	qruleFaceHelper (const Elem *elem, unsigned int side, std::function< T *(QRules &)> rule_fn)
QRules &	qrules (unsigned int dim)
QRules &	qrules (unsigned int dim, SubdomainID block)
	This is a helper function for accessing quadrature rules for a particular dimensionality of element.

Private Attributes
SystemBase &	_sys
SubProblem &	_subproblem
const bool	_displaced
const libMesh::CouplingMatrix *	_cm
	Coupling matrices.
const libMesh::CouplingMatrix &	_nonlocal_cm
const bool &	_computing_residual
	Whether we are currently computing the residual.
const bool &	_computing_jacobian
	Whether we are currently computing the Jacobian.
const bool &	_computing_residual_and_jacobian
	Whether we are currently computing the residual and Jacobian.
std::vector< std::pair< MooseVariableFieldBase *, MooseVariableFieldBase * > >	_cm_ff_entry
	Entries in the coupling matrix for field variables.
std::vector< std::pair< MooseVariableFieldBase *, MooseVariableScalar * > >	_cm_fs_entry
	Entries in the coupling matrix for field variables vs scalar variables.
std::vector< std::pair< MooseVariableScalar *, MooseVariableFieldBase * > >	_cm_sf_entry
	Entries in the coupling matrix for scalar variables vs field variables.
std::vector< std::pair< MooseVariableScalar *, MooseVariableScalar * > >	_cm_ss_entry
	Entries in the coupling matrix for scalar variables.
std::vector< std::pair< MooseVariableFieldBase *, MooseVariableFieldBase * > >	_cm_nonlocal_entry
	Entries in the coupling matrix for field variables for nonlocal calculations.
std::vector< std::vector< std::vector< unsigned char > > >	_jacobian_block_used
	Flag that indicates if the jacobian block was used.
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.
std::vector< std::vector< std::vector< unsigned char > > >	_jacobian_block_lower_used
	Flag that indicates if the jacobian block for the lower dimensional element was used.
const libMesh::DofMap &	_dof_map
	DOF map.
THREAD_ID	_tid
	Thread number (id)
MooseMesh &	_mesh
unsigned int	_mesh_dimension
const FEType	_helper_type
	The finite element type of the FE helper classes.
bool	_user_added_fe_of_helper_type
	Whether user code requested a FEType the same as our _helper_type.
bool	_user_added_fe_face_of_helper_type
bool	_user_added_fe_face_neighbor_of_helper_type
bool	_user_added_fe_neighbor_of_helper_type
bool	_user_added_fe_lower_of_helper_type
std::vector< std::unique_ptr< FEBase > >	_unique_fe_helper
	Containers for holding unique FE helper types if we are doing p-refinement.
std::vector< std::unique_ptr< FEBase > >	_unique_fe_face_helper
std::vector< std::unique_ptr< FEBase > >	_unique_fe_face_neighbor_helper
std::vector< std::unique_ptr< FEBase > >	_unique_fe_neighbor_helper
std::vector< std::unique_ptr< FEBase > >	_unique_fe_lower_helper
bool	_building_helpers
	Whether we are currently building the FE classes for the helpers.
std::shared_ptr< XFEMInterface >	_xfem
	The XFEM controller.
std::map< FEType, FEBase * >	_current_fe
	The "volume" fe object that matches the current elem.
std::map< FEType, FEBase * >	_current_fe_face
	The "face" fe object that matches the current elem.
std::map< FEType, FEBase * >	_current_fe_neighbor
	The "neighbor" fe object that matches the current elem.
std::map< FEType, FEBase * >	_current_fe_face_neighbor
	The "neighbor face" fe object that matches the current elem.
std::map< FEType, FEVectorBase * >	_current_vector_fe
	The "volume" vector fe object that matches the current elem.
std::map< FEType, FEVectorBase * >	_current_vector_fe_face
	The "face" vector fe object that matches the current elem.
std::map< FEType, FEVectorBase * >	_current_vector_fe_neighbor
	The "neighbor" vector fe object that matches the current elem.
std::map< FEType, FEVectorBase * >	_current_vector_fe_face_neighbor
	The "neighbor face" vector fe object that matches the current elem.
std::map< unsigned int, std::map< FEType, FEBase * > >	_fe
	Each dimension's actual fe objects indexed on type.
std::map< unsigned int, std::map< FEType, FEVectorBase * > >	_vector_fe
	Each dimension's actual vector fe objects indexed on type.
std::map< unsigned int, FEBase * >	_holder_fe_helper
	Each dimension's helper objects.
FEBase *	_current_fe_helper
	The current helper object for transforming coordinates.
libMesh::QBase *	_current_qrule
	The current current quadrature rule being used (could be either volumetric or arbitrary - for dirac kernels)
libMesh::QBase *	_current_qrule_volume
	The current volumetric quadrature for the element.
ArbitraryQuadrature *	_current_qrule_arbitrary
	The current arbitrary quadrature rule used within the element interior.
ArbitraryQuadrature *	_current_qrule_arbitrary_face
	The current arbitrary quadrature rule used on the element face.
MooseArray< Point >	_current_q_points
	The current list of quadrature points.
MooseArray< Real >	_current_JxW
	The current list of transformed jacobian weights.
Moose::CoordinateSystemType	_coord_type
	The coordinate system.
MooseArray< Real >	_coord
	The current coordinate transformation coefficients.
MooseArray< ADReal >	_ad_coord
	The AD version of the current coordinate transformation coefficients.
std::unordered_map< SubdomainID, std::vector< QRules > >	_qrules
	Holds quadrature rules for each dimension.
std::map< unsigned int, std::map< FEType, FEBase * > >	_fe_face
	types of finite elements
std::map< unsigned int, std::map< FEType, FEVectorBase * > >	_vector_fe_face
	types of vector finite elements
std::map< unsigned int, FEBase * >	_holder_fe_face_helper
	Each dimension's helper objects.
FEBase *	_current_fe_face_helper
	helper object for transforming coordinates
libMesh::QBase *	_current_qrule_face
	quadrature rule used on faces
ArbitraryQuadrature *	_current_qface_arbitrary
	The current arbitrary quadrature rule used on element faces.
MooseArray< Point >	_current_q_points_face
	The current quadrature points on a face.
MooseArray< Real >	_current_JxW_face
	The current transformed jacobian weights on a face.
MooseArray< Point >	_current_normals
	The current Normal vectors at the quadrature points.
std::vector< Eigen::Map< RealDIMValue > >	_mapped_normals
	Mapped normals.
MooseArray< std::vector< Point > >	_current_tangents
	The current tangent vectors at the quadrature points.
std::vector< dof_id_type >	_extra_elem_ids
	Extra element IDs.
std::vector< dof_id_type >	_neighbor_extra_elem_ids
	Extra element IDs of neighbor.
std::map< unsigned int, const std::vector< Point > * >	_holder_normals
	Holds pointers to the dimension's normal vectors.
std::map< unsigned int, std::map< FEType, FEBase * > >	_fe_neighbor
	types of finite elements
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.
std::map< unsigned int, FEBase * >	_holder_fe_face_neighbor_helper
std::map< unsigned int, std::map< FEType, FEBase * > >	_fe_lower
	FE objects for lower dimensional elements.
std::map< unsigned int, std::map< FEType, FEVectorBase * > >	_vector_fe_lower
	Vector FE objects for lower dimensional elements.
std::map< unsigned int, FEBase * >	_holder_fe_lower_helper
	helper object for transforming coordinates for lower dimensional element quadrature points
libMesh::QBase *	_current_qrule_neighbor
	quadrature rule used on neighbors
MooseArray< Point >	_current_q_points_face_neighbor
	The current quadrature points on the neighbor face.
bool	_need_JxW_neighbor
	Flag to indicate that JxW_neighbor is needed.
MooseArray< Real >	_current_JxW_neighbor
	The current transformed jacobian weights on a neighbor's face.
MooseArray< Real >	_coord_neighbor
	The current coordinate transformation coefficients.
MooseArray< Real >	_coord_msm
	The coordinate transformation coefficients evaluated on the quadrature points of the mortar segment mesh.
const std::vector< Real > *	_JxW_msm
	A JxW for working on mortar segement elements.
std::unique_ptr< FEBase >	_fe_msm
	A FE object for working on mortar segement elements.
libMesh::QBase *	_qrule_msm
	A qrule object for working on mortar segement elements.
bool	_custom_mortar_qrule
	Flag specifying whether a custom quadrature rule has been specified for mortar segment mesh.
libMesh::QBase *	_current_qrule_lower
	quadrature rule used on lower dimensional elements.

Detailed Description

Keeps track of stuff related to assembling.

Definition at line 101 of file Assembly.h.

Member Typedef Documentation

InternalDataKey

using Assembly::InternalDataKey = Moose::PassKey<Moose::Kokkos::Assembly>

Key structure for APIs manipulating internal shape and quadrature data.

Developers in blessed classes may create keys using simple curly braces {} or may be more explicit and use Assembly::InternalDataKey{}

Definition at line 220 of file Assembly.h.

Constructor & Destructor Documentation

Assembly()

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

Definition at line 79 of file Assembly.C.

  : _sys(sys),
    _subproblem(_sys.subproblem()),
    _displaced(dynamic_cast<DisplacedSystem *>(&sys) ? true : false),
    _nonlocal_cm(_subproblem.nonlocalCouplingMatrix(_sys.number())),
    _computing_residual(_subproblem.currentlyComputingResidual()),
    _computing_jacobian(_subproblem.currentlyComputingJacobian()),
    _computing_residual_and_jacobian(_subproblem.currentlyComputingResidualAndJacobian()),
    _dof_map(_sys.dofMap()),
    _tid(tid),
    _mesh(sys.mesh()),
    _mesh_dimension(_mesh.dimension()),
    _helper_type(
        FEType(_mesh.hasSecondOrderElements() ? SECOND : FIRST, LAGRANGE).set_p_refinement(false)),
    _user_added_fe_of_helper_type(false),
    _user_added_fe_face_of_helper_type(false),
    _user_added_fe_face_neighbor_of_helper_type(false),
    _user_added_fe_neighbor_of_helper_type(false),
    _user_added_fe_lower_of_helper_type(false),
    _building_helpers(false),
    _current_qrule(nullptr),
    _current_qrule_volume(nullptr),
    _current_qrule_arbitrary(nullptr),
    _coord_type(Moose::COORD_XYZ),
    _current_qrule_face(nullptr),
    _current_qface_arbitrary(nullptr),
    _current_qrule_neighbor(nullptr),
    _need_JxW_neighbor(false),
    _qrule_msm(nullptr),
    _custom_mortar_qrule(false),
    _current_qrule_lower(nullptr),
 
    _current_elem(nullptr),
    _current_elem_volume(0),
    _current_side(0),
    _current_side_elem(nullptr),
    _current_side_volume(0),
    _current_neighbor_elem(nullptr),
    _current_neighbor_side(0),
    _current_neighbor_side_elem(nullptr),
    _need_neighbor_elem_volume(false),
    _current_neighbor_volume(0),
    _current_node(nullptr),
    _current_neighbor_node(nullptr),
    _current_elem_volume_computed(false),
    _current_side_volume_computed(false),
 
    _current_lower_d_elem(nullptr),
    _current_neighbor_lower_d_elem(nullptr),
    _need_lower_d_elem_volume(false),
    _need_neighbor_lower_d_elem_volume(false),
    _need_dual(false),
 
    _residual_vector_tags(_subproblem.getVectorTags(Moose::VECTOR_TAG_RESIDUAL)),
    _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),
    _calculate_ad_coord(false),
    _prepared_for_p_refinement(false)
{
  const Order helper_order = _mesh.hasSecondOrderElements() ? SECOND : FIRST;
  _building_helpers = true;
  // Build fe's for the helpers
  buildFE(_helper_type);
  buildFaceFE(_helper_type);
  buildNeighborFE(_helper_type);
  buildFaceNeighborFE(_helper_type);
  buildLowerDFE(_helper_type);
  _building_helpers = false;
 
  // 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][_helper_type];
    _holder_fe_face_helper[dim] = _fe_face[dim][_helper_type];
    _holder_fe_face_neighbor_helper[dim] = _fe_face_neighbor[dim][_helper_type];
    _holder_fe_neighbor_helper[dim] = _fe_neighbor[dim][_helper_type];
  }
 
  for (unsigned int dim = 0; dim < _mesh_dimension; dim++)
    _holder_fe_lower_helper[dim] = _fe_lower[dim][_helper_type];
 
  // request phi, dphi, xyz, JxW, etc. data
  helpersRequestData();
 
  // For 3D mortar, mortar segments are always TRI3 elements so we want FIRST LAGRANGE regardless
  // of discretization
  const auto mortar_helper_type =
      FEType(_mesh_dimension == 2 ? helper_order : FIRST, LAGRANGE).set_p_refinement(false);
  _fe_msm = FEGenericBase<Real>::build(_mesh_dimension - 1, mortar_helper_type);
  // This FE object should not take part in p-refinement
  _fe_msm->add_p_level_in_reinit(false);
  _JxW_msm = &_fe_msm->get_JxW();
  // Prerequest xyz so that it is computed for _fe_msm so that it can be used for calculating
  // _coord_msm
  _fe_msm->get_xyz();
 
  _extra_elem_ids.resize(_mesh.getMesh().n_elem_integers() + 1);
  _neighbor_extra_elem_ids.resize(_mesh.getMesh().n_elem_integers() + 1);
}

~Assembly()

Assembly::~Assembly ( )

virtual

Definition at line 187 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 - 1; dim++)
    for (auto & it : _fe_lower[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 (unsigned int dim = 0; dim <= _mesh_dimension - 1; dim++)
    for (auto & it : _vector_fe_lower[dim])
      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();
 
  _current_physical_points.release();
 
  _coord.release();
  _coord_neighbor.release();
  _coord_msm.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();
 
  delete _qrule_msm;
}

Member Function Documentation

activateDual()

void Assembly::activateDual ( )

inline

Indicates that dual shape functions are used for mortar constraint.

Definition at line 609 of file Assembly.h.

{ _need_dual = true; }

Referenced by MortarConstraintBase::MortarConstraintBase().

adCoordTransformation()

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 292 of file Assembly.h.

  {
    // Coord values for non-cartesian coordinate systems are functions of the locations of the
    // quadrature points in physical space. We also have no way of knowing whether this was called
    // from a volumetric or face object so we should set both volumetric and face xyz to true
    _calculate_xyz = true;
    _calculate_face_xyz = true;
 
    _calculate_ad_coord = true;
    return _ad_coord;
  }

adCurvatures()

const MooseArray< ADReal > & Assembly::adCurvatures

(

)

const

Definition at line 4843 of file Assembly.C.

{
  _calculate_curvatures = true;
  // Must prerequest the second derivatives. Sadly because there is only one
  // _need_second_derivative map for both volumetric and face FE objects we must request both here
  feSecondPhi<Real>(_helper_type);
  feSecondPhiFace<Real>(_helper_type);
  return _ad_curvatures;
}

addCachedJacobian()

void Assembly::addCachedJacobian

(

GlobalDataKey

)

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 3852 of file Assembly.C.

{
#ifndef NDEBUG
  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!");
  }
#endif
 
  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);
  }
}

Referenced by SubProblem::addCachedJacobian(), NonlinearSystemBase::computeJacobianInternal(), and ComputeMortarFunctor::operator()().

addCachedResidualDirectly()

void Assembly::addCachedResidualDirectly	(	NumericVector< Number > &	residual,
		GlobalDataKey	,
		const VectorTag &	vector_tag
	)

Adds the values that have been cached by calling cacheResidual(), cacheResidualNeighbor(), and/or cacheResidualLower() to a user-defined residual (that is, not necessarily the vector that vector_tag points to)

Note that this will also clear the cache.

Definition at line 3567 of file Assembly.C.

{
  const auto & values = _cached_residual_values[vector_tag._type_id];
  const auto & rows = _cached_residual_rows[vector_tag._type_id];
 
  mooseAssert(values.size() == rows.size(),
              "Number of cached residuals and number of rows must match!");
 
  if (!values.empty())
  {
    residual.add_vector(values, rows);
    clearCachedResiduals(vector_tag);
  }
}

Referenced by addCachedResiduals().

addCachedResiduals()

void Assembly::addCachedResiduals	(	GlobalDataKey	,
		const std::vector< VectorTag > &	tags
	)

Pushes all cached residuals to the global residual vectors associated with each tag.

Note that this will also clear the cache.

Definition at line 3522 of file Assembly.C.

{
  for (const auto & vector_tag : tags)
  {
    if (!_sys.hasVector(vector_tag._id))
    {
      _cached_residual_values[vector_tag._type_id].clear();
      _cached_residual_rows[vector_tag._type_id].clear();
      continue;
    }
    addCachedResidualDirectly(_sys.getVector(vector_tag._id), GlobalDataKey{}, vector_tag);
  }
}

Referenced by SubProblem::addCachedResidual(), and ComputeMortarFunctor::operator()().

addJacobian()

void Assembly::addJacobian

(

GlobalDataKey

)

Adds all local Jacobian to the global Jacobian matrices.

Definition at line 3909 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 ( libMesh::SparseMatrix< Number > &  jacobian, DenseMatrix< Number > &  jac_block, const MooseVariableBase &  ivar, const MooseVariableBase &  jvar, const std::vector< dof_id_type > &  idof_indices, const std::vector< dof_id_type > &  jdof_indices  )

private

Add a local Jacobian block to a global Jacobian with proper scaling.

Definition at line 3607 of file Assembly.C.

{
  if (idof_indices.size() == 0 || jdof_indices.size() == 0)
    return;
  if (jac_block.n() == 0 || jac_block.m() == 0)
    return;
 
  const auto & scaling_factors = ivar.arrayScalingFactor();
  const unsigned int iv = ivar.number();
  const unsigned int jv = jvar.number();
 
  for (unsigned int i = 0; i < ivar.count(); ++i)
  {
    for (const auto & jt : libMesh::ConstCouplingRow(iv + i, *_cm))
    {
      if (jt < jv || jt >= jv + jvar.count())
        continue;
      unsigned int j = jt - jv;
 
      auto di = ivar.componentDofIndices(idof_indices, i);
      auto dj = jvar.componentDofIndices(jdof_indices, j);
      auto indof = di.size();
      auto jndof = dj.size();
 
      unsigned int jj = j;
      if (iv == jv && _component_block_diagonal[iv])
        // here i must be equal to j
        jj = 0;
 
      auto sub = jac_block.sub_matrix(i * indof, indof, jj * jndof, jndof);
      if (scaling_factors[i] != 1.0)
        sub *= scaling_factors[i];
 
      // If we're computing the jacobian for automatically scaling variables we do not want
      // to constrain the element matrix because it introduces 1s on the diagonal for the
      // constrained dofs
      if (!_sys.computingScalingJacobian())
        _dof_map.constrain_element_matrix(sub, di, dj, false);
 
      jacobian.add_matrix(sub, di, dj);
    }
  }
}

addJacobianBlock() [2/2]

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

Adds element matrix for ivar rows and jvar columns to the global Jacobian matrix.

Referenced by addJacobianBlockTags(), addJacobianCoupledVarPair(), addJacobianLowerD(), addJacobianNeighbor(), addJacobianNeighborLowerD(), and addJacobianNonlocal().

addJacobianBlockNonlocal()

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

Adds non-local element matrix for ivar rows and jvar columns to the global Jacobian matrix.

Definition at line 4335 of file Assembly.C.

{
  if (idof_indices.size() == 0 || jdof_indices.size() == 0)
    return;
  if (jacobian.n() == 0 || jacobian.m() == 0)
    return;
  if (!(*_cm)(ivar, jvar))
    return;
 
  auto & iv = _sys.getVariable(_tid, ivar);
  auto & jv = _sys.getVariable(_tid, jvar);
  auto & scaling_factor = iv.arrayScalingFactor();
 
  const unsigned int ivn = iv.number();
  const unsigned int jvn = jv.number();
  auto & keg = jacobianBlockNonlocal(ivn, jvn, LocalDataKey{}, tag);
 
  // It is guaranteed by design iv.number <= ivar since iv is obtained
  // through SystemBase::getVariable with ivar.
  // Most of times ivar will just be equal to iv.number except for array variables,
  // where ivar could be a number for a component of an array variable but calling
  // getVariable will return the array variable that has the number of the 0th component.
  // It is the same for jvar.
  const unsigned int i = ivar - ivn;
  const unsigned int j = jvar - jvn;
 
  // DoF indices are independently given
  auto di = idof_indices;
  auto dj = jdof_indices;
 
  auto indof = di.size();
  auto jndof = dj.size();
 
  unsigned int jj = j;
  if (ivar == jvar && _component_block_diagonal[ivn])
    jj = 0;
 
  auto sub = keg.sub_matrix(i * indof, indof, jj * jndof, jndof);
  // If we're computing the jacobian for automatically scaling variables we do not want to
  // constrain the element matrix because it introduces 1s on the diagonal for the constrained
  // dofs
  if (!_sys.computingScalingJacobian())
    dof_map.constrain_element_matrix(sub, di, dj, false);
 
  if (scaling_factor[i] != 1.0)
    sub *= scaling_factor[i];
 
  jacobian.add_matrix(sub, di, dj);
}

Referenced by addJacobianBlockNonlocalTags().

addJacobianBlockNonlocalTags()

void Assembly::addJacobianBlockNonlocalTags	(	libMesh::SparseMatrix< Number > &	jacobian,
		unsigned int	ivar,
		unsigned int	jvar,
		const libMesh::DofMap &	dof_map,
		const std::vector< dof_id_type > &	idof_indices,
		const std::vector< dof_id_type > &	jdof_indices,
		GlobalDataKey	,
		const std::set< TagID > &	tags
	)

Adds non-local element matrix for ivar rows and jvar columns to the global Jacobian matrix.

Definition at line 4393 of file Assembly.C.

{
  for (auto tag : tags)
    addJacobianBlockNonlocal(
        jacobian, ivar, jvar, dof_map, idof_indices, jdof_indices, GlobalDataKey{}, tag);
}

addJacobianBlockTags()

void Assembly::addJacobianBlockTags	(	libMesh::SparseMatrix< Number > &	jacobian,
		unsigned int	ivar,
		unsigned int	jvar,
		const libMesh::DofMap &	dof_map,
		std::vector< dof_id_type > &	dof_indices,
		GlobalDataKey	,
		const std::set< TagID > &	tags
	)

Add element matrix for ivar rows and jvar columns to the global Jacobian matrix for given tags.

Definition at line 4267 of file Assembly.C.

{
  for (auto tag : tags)
    addJacobianBlock(jacobian, ivar, jvar, dof_map, dof_indices, GlobalDataKey{}, tag);
}

addJacobianCoupledVarPair()

void Assembly::addJacobianCoupledVarPair ( const MooseVariableBase &  ivar, const MooseVariableBase &  jvar  )

inlineprivate

Adds element matrices for ivar rows and jvar columns to the global Jacobian matrices.

Definition at line 3894 of file Assembly.C.

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

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

addJacobianLowerD()

void Assembly::addJacobianLowerD

(

GlobalDataKey

)

Add portions of the Jacobian of LowerLower, LowerSecondary, and SecondaryLower for boundary conditions.

Secondary indicates the boundary element. Lower denotes the lower-dimensional element living on the boundary side.

Definition at line 4060 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_lower_used) tag = 0; tag < _jacobian_block_lower_used.size();
         tag++)
      if (jacobianBlockLowerUsed(tag, i, j) && _sys.hasMatrix(tag))
      {
        addJacobianBlock(_sys.getMatrix(tag),
                         jacobianBlockMortar(Moose::LowerLower, i, j, LocalDataKey{}, tag),
                         *ivar,
                         *jvar,
                         ivar->dofIndicesLower(),
                         jvar->dofIndicesLower());
 
        addJacobianBlock(_sys.getMatrix(tag),
                         jacobianBlockMortar(Moose::LowerSecondary, i, j, LocalDataKey{}, tag),
                         *ivar,
                         *jvar,
                         ivar->dofIndicesLower(),
                         jvar->dofIndices());
 
        addJacobianBlock(_sys.getMatrix(tag),
                         jacobianBlockMortar(Moose::SecondaryLower, i, j, LocalDataKey{}, tag),
                         *ivar,
                         *jvar,
                         ivar->dofIndices(),
                         jvar->dofIndicesLower());
      }
  }
}

addJacobianNeighbor() [1/2]

void Assembly::addJacobianNeighbor

(

GlobalDataKey

)

Add ElementNeighbor, NeighborElement, and NeighborNeighbor portions of the Jacobian for compute objects like DGKernels.

Definition at line 3944 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 (jacobianBlockNeighborUsed(tag, i, j) && _sys.hasMatrix(tag))
      {
        addJacobianBlock(_sys.getMatrix(tag),
                         jacobianBlockNeighbor(Moose::ElementNeighbor, i, j, LocalDataKey{}, tag),
                         *ivar,
                         *jvar,
                         ivar->dofIndices(),
                         jvar->dofIndicesNeighbor());
 
        addJacobianBlock(_sys.getMatrix(tag),
                         jacobianBlockNeighbor(Moose::NeighborElement, i, j, LocalDataKey{}, tag),
                         *ivar,
                         *jvar,
                         ivar->dofIndicesNeighbor(),
                         jvar->dofIndices());
 
        addJacobianBlock(_sys.getMatrix(tag),
                         jacobianBlockNeighbor(Moose::NeighborNeighbor, i, j, LocalDataKey{}, tag),
                         *ivar,
                         *jvar,
                         ivar->dofIndicesNeighbor(),
                         jvar->dofIndicesNeighbor());
      }
  }
}

Referenced by addJacobianNeighborTags().

addJacobianNeighbor() [2/2]

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

Adds three neighboring element matrices for ivar rows and jvar columns to the global Jacobian matrix.

addJacobianNeighborLowerD()

void Assembly::addJacobianNeighborLowerD

(

GlobalDataKey

)

Add all portions of the Jacobian except PrimaryPrimary, e.g.

LowerLower, LowerSecondary, LowerPrimary, SecondaryLower, SecondarySecondary, SecondaryPrimary, PrimaryLower, PrimarySecondary, for mortar-like objects. Primary indicates the interior parent element on the primary side of the mortar interface. Secondary indicates the neighbor of the interior parent element. Lower denotes the lower-dimensional element living on the primary side of the mortar interface.

Definition at line 3982 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_lower_used) tag = 0; tag < _jacobian_block_lower_used.size();
         tag++)
      if (jacobianBlockLowerUsed(tag, i, j) && _sys.hasMatrix(tag))
      {
        addJacobianBlock(_sys.getMatrix(tag),
                         jacobianBlockMortar(Moose::LowerLower, i, j, LocalDataKey{}, tag),
                         *ivar,
                         *jvar,
                         ivar->dofIndicesLower(),
                         jvar->dofIndicesLower());
 
        addJacobianBlock(_sys.getMatrix(tag),
                         jacobianBlockMortar(Moose::LowerSecondary, i, j, LocalDataKey{}, tag),
                         *ivar,
                         *jvar,
                         ivar->dofIndicesLower(),
                         jvar->dofIndicesNeighbor());
 
        addJacobianBlock(_sys.getMatrix(tag),
                         jacobianBlockMortar(Moose::LowerPrimary, i, j, LocalDataKey{}, tag),
                         *ivar,
                         *jvar,
                         ivar->dofIndicesLower(),
                         jvar->dofIndices());
 
        addJacobianBlock(_sys.getMatrix(tag),
                         jacobianBlockMortar(Moose::SecondaryLower, i, j, LocalDataKey{}, tag),
                         *ivar,
                         *jvar,
                         ivar->dofIndicesNeighbor(),
                         jvar->dofIndicesLower());
 
        addJacobianBlock(_sys.getMatrix(tag),
                         jacobianBlockMortar(Moose::PrimaryLower, i, j, LocalDataKey{}, tag),
                         *ivar,
                         *jvar,
                         ivar->dofIndices(),
                         jvar->dofIndicesLower());
      }
 
    for (MooseIndex(_jacobian_block_neighbor_used) tag = 0;
         tag < _jacobian_block_neighbor_used.size();
         tag++)
      if (jacobianBlockNeighborUsed(tag, i, j) && _sys.hasMatrix(tag))
      {
        addJacobianBlock(_sys.getMatrix(tag),
                         jacobianBlockNeighbor(Moose::ElementNeighbor, i, j, LocalDataKey{}, tag),
                         *ivar,
                         *jvar,
                         ivar->dofIndices(),
                         jvar->dofIndicesNeighbor());
 
        addJacobianBlock(_sys.getMatrix(tag),
                         jacobianBlockNeighbor(Moose::NeighborElement, i, j, LocalDataKey{}, tag),
                         *ivar,
                         *jvar,
                         ivar->dofIndicesNeighbor(),
                         jvar->dofIndices());
 
        addJacobianBlock(_sys.getMatrix(tag),
                         jacobianBlockNeighbor(Moose::NeighborNeighbor, i, j, LocalDataKey{}, tag),
                         *ivar,
                         *jvar,
                         ivar->dofIndicesNeighbor(),
                         jvar->dofIndicesNeighbor());
      }
  }
}

addJacobianNeighborTags()

void Assembly::addJacobianNeighborTags	(	libMesh::SparseMatrix< Number > &	jacobian,
		unsigned int	ivar,
		unsigned int	jvar,
		const libMesh::DofMap &	dof_map,
		std::vector< dof_id_type > &	dof_indices,
		std::vector< dof_id_type > &	neighbor_dof_indices,
		GlobalDataKey	,
		const std::set< TagID > &	tags
	)

Adds three neighboring element matrices for ivar rows and jvar columns to the global Jacobian matrix.

Definition at line 4477 of file Assembly.C.

{
  for (const auto tag : tags)
    addJacobianNeighbor(
        jacobian, ivar, jvar, dof_map, dof_indices, neighbor_dof_indices, GlobalDataKey{}, tag);
}

addJacobianNonlocal()

void Assembly::addJacobianNonlocal

(

GlobalDataKey

)

Adds non-local Jacobian to the global Jacobian matrices.

Definition at line 3922 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 (jacobianBlockNonlocalUsed(tag, i, j) && _sys.hasMatrix(tag))
        addJacobianBlock(_sys.getMatrix(tag),
                         jacobianBlockNonlocal(i, j, LocalDataKey{}, tag),
                         *ivar,
                         *jvar,
                         ivar->dofIndices(),
                         jvar->allDofIndices());
  }
}

addJacobianOffDiagScalar()

void Assembly::addJacobianOffDiagScalar	(	unsigned int	ivar,
		GlobalDataKey
	)

Add Jacobians for a scalar variables with all other field variables into the global Jacobian matrices.

Definition at line 4499 of file Assembly.C.

{
  for (const auto & it : _cm_sf_entry)
    if (it.first->number() == ivar)
      addJacobianCoupledVarPair(*it.first, *it.second);
}

addJacobianScalar()

void Assembly::addJacobianScalar

(

GlobalDataKey

)

Add Jacobians for pairs of scalar variables into the global Jacobian matrices.

Definition at line 4492 of file Assembly.C.

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

addResidual() [1/2]

void Assembly::addResidual ( const VectorTag &  vector_tag )

private

Add local residuals of all field variables for a tag onto the tag's residual vector.

Definition at line 3356 of file Assembly.C.

{
  mooseAssert(vector_tag._type == Moose::VECTOR_TAG_RESIDUAL,
              "Non-residual tag in Assembly::addResidual");
 
  auto & tag_Re = _sub_Re[vector_tag._type_id];
  NumericVector<Number> & residual = _sys.getVector(vector_tag._id);
  const std::vector<MooseVariableFEBase *> & vars = _sys.getVariables(_tid);
  for (const auto & var : vars)
    addResidualBlock(residual, tag_Re[var->number()], var->dofIndices(), var->arrayScalingFactor());
}

addResidual() [2/2]

void Assembly::addResidual	(	GlobalDataKey	,
		const std::vector< VectorTag > &	vector_tags
	)

Add local residuals of all field variables for a set of tags onto the global residual vectors associated with the tags.

Definition at line 3369 of file Assembly.C.

{
  for (const auto & vector_tag : vector_tags)
    if (_sys.hasVector(vector_tag._id))
      addResidual(vector_tag);
}

Referenced by addResidual().

addResidualBlock()

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

private

Add a local residual block to a global residual vector with proper scaling.

Definition at line 3303 of file Assembly.C.

{
  if (dof_indices.size() > 0 && res_block.size())
  {
    _temp_dof_indices = dof_indices;
    _tmp_Re = res_block;
    processLocalResidual(_tmp_Re, _temp_dof_indices, scaling_factor);
    residual.add_vector(_tmp_Re, _temp_dof_indices);
  }
}

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

addResidualLower() [1/2]

void Assembly::addResidualLower ( const VectorTag &  vector_tag )

private

Add local lower-dimensional block residuals of all field variables for a tag onto the tag's residual vector.

Definition at line 3399 of file Assembly.C.

{
  mooseAssert(vector_tag._type == Moose::VECTOR_TAG_RESIDUAL,
              "Non-residual tag in Assembly::addResidualLower");
 
  auto & tag_Rl = _sub_Rl[vector_tag._type_id];
  NumericVector<Number> & residual = _sys.getVector(vector_tag._id);
  const std::vector<MooseVariableFEBase *> & vars = _sys.getVariables(_tid);
  for (const auto & var : vars)
    addResidualBlock(
        residual, tag_Rl[var->number()], var->dofIndicesLower(), var->arrayScalingFactor());
}

addResidualLower() [2/2]

void Assembly::addResidualLower	(	GlobalDataKey	,
		const std::vector< VectorTag > &	vector_tags
	)

Add local neighbor residuals of all field variables for a set of tags onto the global residual vectors associated with the tags.

Definition at line 3413 of file Assembly.C.

{
  for (const auto & vector_tag : vector_tags)
    if (_sys.hasVector(vector_tag._id))
      addResidualLower(vector_tag);
}

Referenced by addResidualLower().

addResidualNeighbor() [1/2]

void Assembly::addResidualNeighbor ( const VectorTag &  vector_tag )

private

Add local neighbor residuals of all field variables for a tag onto the tag's residual vector.

Definition at line 3377 of file Assembly.C.

{
  mooseAssert(vector_tag._type == Moose::VECTOR_TAG_RESIDUAL,
              "Non-residual tag in Assembly::addResidualNeighbor");
 
  auto & tag_Rn = _sub_Rn[vector_tag._type_id];
  NumericVector<Number> & residual = _sys.getVector(vector_tag._id);
  const std::vector<MooseVariableFEBase *> & vars = _sys.getVariables(_tid);
  for (const auto & var : vars)
    addResidualBlock(
        residual, tag_Rn[var->number()], var->dofIndicesNeighbor(), var->arrayScalingFactor());
}

addResidualNeighbor() [2/2]

void Assembly::addResidualNeighbor	(	GlobalDataKey	,
		const std::vector< VectorTag > &	vector_tags
	)

Add local neighbor residuals of all field variables for a set of tags onto the global residual vectors associated with the tags.

Definition at line 3391 of file Assembly.C.

{
  for (const auto & vector_tag : vector_tags)
    if (_sys.hasVector(vector_tag._id))
      addResidualNeighbor(vector_tag);
}

Referenced by addResidualNeighbor().

addResidualScalar() [1/2]

void Assembly::addResidualScalar ( const VectorTag &  vector_tag )

private

Add residuals of all scalar variables for a tag onto the tag's residual vector.

Definition at line 3422 of file Assembly.C.

{
  mooseAssert(vector_tag._type == Moose::VECTOR_TAG_RESIDUAL,
              "Non-residual tag in Assembly::addResidualScalar");
 
  // add the scalar variables residuals
  auto & tag_Re = _sub_Re[vector_tag._type_id];
  NumericVector<Number> & residual = _sys.getVector(vector_tag._id);
  const std::vector<MooseVariableScalar *> & vars = _sys.getScalarVariables(_tid);
  for (const auto & var : vars)
    addResidualBlock(residual, tag_Re[var->number()], var->dofIndices(), var->arrayScalingFactor());
}

addResidualScalar() [2/2]

void Assembly::addResidualScalar	(	GlobalDataKey	,
		const std::vector< VectorTag > &	vector_tags
	)

Add residuals of all scalar variables for a set of tags onto the global residual vectors associated with the tags.

Definition at line 3436 of file Assembly.C.

{
  for (const auto & vector_tag : vector_tags)
    if (_sys.hasVector(vector_tag._id))
      addResidualScalar(vector_tag);
}

Referenced by addResidualScalar().

adGradPhi() [1/2]

template<>

const ADTemplateVariablePhiGradient< RealVectorValue > & Assembly::adGradPhi ( const MooseVariableFE< RealVectorValue > &  v ) const

inline

Definition at line 3039 of file Assembly.h.

{
  return _ad_vector_grad_phi_data.at(v.feType());
}

adGradPhi() [2/2]

template<typename T >

const ADTemplateVariablePhiGradient< T > & Assembly::adGradPhi ( const MooseVariableFE< T > &  v ) const

inline

Definition at line 1314 of file Assembly.h.

  {
    return _ad_grad_phi_data.at(v.feType());
  }

adJxW()

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

inline

Definition at line 270 of file Assembly.h.

{ return _ad_JxW; }

adJxWFace()

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

inline

Definition at line 272 of file Assembly.h.

{ return _ad_JxW_face; }

adNormals()

const MooseArray< ADPoint > & Assembly::adNormals ( ) const

inline

Definition at line 385 of file Assembly.h.

{ return _ad_normals; }

adQPoints()

const MooseArray< ADPoint > & Assembly::adQPoints ( ) const

inline

Definition at line 387 of file Assembly.h.

  {
    _calculate_xyz = true;
    return _ad_q_points;
  }

Referenced by genericQPoints().

adQPointsFace()

const MooseArray< ADPoint > & Assembly::adQPointsFace ( ) const

inline

Definition at line 393 of file Assembly.h.

  {
    _calculate_face_xyz = true;
    return _ad_q_points_face;
  }

assignDisplacements()

void Assembly::assignDisplacements ( std::vector< std::pair< unsigned int, unsigned short > > &&  disp_numbers_and_directions )

inline

Assign the displacement numbers and directions.

Definition at line 3218 of file Assembly.h.

{
  _disp_numbers_and_directions = std::move(disp_numbers_and_directions);
}

attachQRuleElem()

const libMesh::QBase * Assembly::attachQRuleElem ( unsigned int  dim, FEBase &  fe  )

inline

Attaches the current elem/volume quadrature rule to the given fe.

The current subdomain (as set via setCurrentSubdomainID is used to determine the correct rule. The attached quadrature rule is also returned.

Definition at line 1906 of file Assembly.h.

  {
    auto qrule = qrules(dim).vol.get();
    fe.attach_quadrature_rule(qrule);
    return qrule;
  }

attachQRuleFace()

const libMesh::QBase * Assembly::attachQRuleFace ( unsigned int  dim, FEBase &  fe  )

inline

Attaches the current face/area quadrature rule to the given fe.

The current subdomain (as set via setCurrentSubdomainID is used to determine the correct rule. The attached quadrature rule is also returned.

Definition at line 1918 of file Assembly.h.

  {
    auto qrule = qrules(dim).face.get();
    fe.attach_quadrature_rule(qrule);
    return qrule;
  }

buildFaceFE()

void Assembly::buildFaceFE ( FEType  type ) const

private

Build FEs for a face with a type.

Parameters

type	The type of FE

Definition at line 296 of file Assembly.C.

{
  if (!_building_helpers && type == _helper_type)
    _user_added_fe_face_of_helper_type = true;
 
  if (!_fe_shape_data_face[type])
    _fe_shape_data_face[type] = std::make_unique<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]->add_p_level_in_reinit(type.p_refinement);
    }
 
    _fe_face[dim][type]->get_phi();
    _fe_face[dim][type]->get_dphi();
    if (_need_second_derivative.count(type))
      _fe_face[dim][type]->get_d2phi();
  }
}

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

buildFaceNeighborFE()

void Assembly::buildFaceNeighborFE ( FEType  type ) const

private

Build FEs for a neighbor face with a type.

Parameters

type	The type of FE

Definition at line 346 of file Assembly.C.

{
  if (!_building_helpers && type == _helper_type)
    _user_added_fe_face_neighbor_of_helper_type = true;
 
  if (!_fe_shape_data_face_neighbor[type])
    _fe_shape_data_face_neighbor[type] = std::make_unique<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]->add_p_level_in_reinit(type.p_refinement);
    }
 
    _fe_face_neighbor[dim][type]->get_phi();
    _fe_face_neighbor[dim][type]->get_dphi();
    if (_need_second_derivative_neighbor.count(type))
      _fe_face_neighbor[dim][type]->get_d2phi();
  }
}

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

buildFE()

void Assembly::buildFE ( FEType  type ) const

private

Build FEs with a type.

Parameters

type	The type of FE

Definition at line 267 of file Assembly.C.

{
  if (!_building_helpers && type == _helper_type)
    _user_added_fe_of_helper_type = true;
 
  if (!_fe_shape_data[type])
    _fe_shape_data[type] = std::make_unique<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]->add_p_level_in_reinit(type.p_refinement);
    }
 
    _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.count(type))
      _fe[dim][type]->get_d2phi();
  }
}

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

buildLowerDDualFE()

void Assembly::buildLowerDDualFE ( FEType  type ) const

private

Definition at line 398 of file Assembly.C.

{
  if (!_fe_shape_data_dual_lower[type])
    _fe_shape_data_dual_lower[type] = std::make_unique<FEShapeData>();
 
  // Build an FE object for this type for each dimension up to the dimension of
  // the current mesh minus one (because this is for lower-dimensional
  // elements!)
  for (unsigned int dim = 0; dim <= _mesh_dimension - 1; dim++)
  {
    if (!_fe_lower[dim][type])
    {
      _fe_lower[dim][type] = FEGenericBase<Real>::build(dim, type).release();
      _fe_lower[dim][type]->add_p_level_in_reinit(type.p_refinement);
    }
 
    _fe_lower[dim][type]->get_dual_phi();
    _fe_lower[dim][type]->get_dual_dphi();
    if (_need_second_derivative.count(type))
      _fe_lower[dim][type]->get_dual_d2phi();
  }
}

Referenced by feDualPhiLower(), and feGradDualPhiLower().

buildLowerDFE()

void Assembly::buildLowerDFE ( FEType  type ) const

private

Build FEs for a lower dimensional element with a type.

Parameters

type	The type of FE

Definition at line 371 of file Assembly.C.

{
  if (!_building_helpers && type == _helper_type)
    _user_added_fe_lower_of_helper_type = true;
 
  if (!_fe_shape_data_lower[type])
    _fe_shape_data_lower[type] = std::make_unique<FEShapeData>();
 
  // Build an FE object for this type for each dimension up to the dimension of
  // the current mesh minus one (because this is for lower-dimensional
  // elements!)
  for (unsigned int dim = 0; dim <= _mesh_dimension - 1; dim++)
  {
    if (!_fe_lower[dim][type])
    {
      _fe_lower[dim][type] = FEGenericBase<Real>::build(dim, type).release();
      _fe_lower[dim][type]->add_p_level_in_reinit(type.p_refinement);
    }
 
    _fe_lower[dim][type]->get_phi();
    _fe_lower[dim][type]->get_dphi();
    if (_need_second_derivative.count(type))
      _fe_lower[dim][type]->get_d2phi();
  }
}

Referenced by Assembly(), feGradPhiLower(), and fePhiLower().

buildNeighborFE()

void Assembly::buildNeighborFE ( FEType  type ) const

private

Build FEs for a neighbor with a type.

Parameters

type	The type of FE

Definition at line 321 of file Assembly.C.

{
  if (!_building_helpers && type == _helper_type)
    _user_added_fe_neighbor_of_helper_type = true;
 
  if (!_fe_shape_data_neighbor[type])
    _fe_shape_data_neighbor[type] = std::make_unique<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]->add_p_level_in_reinit(type.p_refinement);
    }
 
    _fe_neighbor[dim][type]->get_phi();
    _fe_neighbor[dim][type]->get_dphi();
    if (_need_second_derivative_neighbor.count(type))
      _fe_neighbor[dim][type]->get_d2phi();
  }
}

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

buildVectorDualLowerDFE()

void Assembly::buildVectorDualLowerDFE ( FEType  type ) const

private

Definition at line 450 of file Assembly.C.

{
  if (!_vector_fe_shape_data_dual_lower[type])
    _vector_fe_shape_data_dual_lower[type] = std::make_unique<VectorFEShapeData>();
 
  // Build an FE object for this type for each dimension up to the dimension of
  // the current mesh minus one (because this is for lower-dimensional
  // elements!)
  unsigned int dim = ((type.family == LAGRANGE_VEC) || (type.family == MONOMIAL_VEC)) ? 0 : 2;
  const auto ending_dim = cast_int<unsigned int>(_mesh_dimension - 1);
  if (ending_dim < dim)
    return;
  for (; dim <= ending_dim; dim++)
  {
    if (!_vector_fe_lower[dim][type])
    {
      _vector_fe_lower[dim][type] = FEVectorBase::build(dim, type).release();
      _vector_fe_lower[dim][type]->add_p_level_in_reinit(type.p_refinement);
    }
 
    _vector_fe_lower[dim][type]->get_dual_phi();
    _vector_fe_lower[dim][type]->get_dual_dphi();
    if (_need_second_derivative.count(type))
      _vector_fe_lower[dim][type]->get_dual_d2phi();
  }
}

buildVectorFaceFE()

void Assembly::buildVectorFaceFE ( FEType  type ) const

private

Build Vector FEs for a face with a type.

Parameters

type	The type of FE

Definition at line 512 of file Assembly.C.

{
  if (!_vector_fe_shape_data_face[type])
    _vector_fe_shape_data_face[type] = std::make_unique<VectorFEShapeData>();
 
  // Note that NEDELEC_ONE and RAVIART_THOMAS elements can only be built for dimension > 2
  unsigned int min_dim;
  if (type.family == NEDELEC_ONE || type.family == RAVIART_THOMAS ||
      type.family == L2_RAVIART_THOMAS)
    min_dim = 2;
  else
    min_dim = 0;
 
  // Build an FE object for this type for each dimension from the min_dim up to the dimension of the
  // current mesh
  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]->add_p_level_in_reinit(type.p_refinement);
    }
 
    _vector_fe_face[dim][type]->get_phi();
    _vector_fe_face[dim][type]->get_dphi();
    if (_need_curl.count(type))
      _vector_fe_face[dim][type]->get_curl_phi();
    if (_need_face_div.count(type))
      _vector_fe_face[dim][type]->get_div_phi();
  }
}

Referenced by getVectorFEFace().

buildVectorFaceNeighborFE()

void Assembly::buildVectorFaceNeighborFE ( FEType  type ) const

private

Build Vector FEs for a neighbor face with a type.

Parameters

type	The type of FE

Definition at line 578 of file Assembly.C.

{
  if (!_vector_fe_shape_data_face_neighbor[type])
    _vector_fe_shape_data_face_neighbor[type] = std::make_unique<VectorFEShapeData>();
 
  // Note that NEDELEC_ONE and RAVIART_THOMAS elements can only be built for dimension > 2
  unsigned int min_dim;
  if (type.family == NEDELEC_ONE || type.family == RAVIART_THOMAS ||
      type.family == L2_RAVIART_THOMAS)
    min_dim = 2;
  else
    min_dim = 0;
 
  // Build an FE object for this type for each dimension from the min_dim up to the dimension of the
  // current mesh
  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]->add_p_level_in_reinit(type.p_refinement);
    }
 
    _vector_fe_face_neighbor[dim][type]->get_phi();
    _vector_fe_face_neighbor[dim][type]->get_dphi();
    if (_need_curl.count(type))
      _vector_fe_face_neighbor[dim][type]->get_curl_phi();
    if (_need_face_neighbor_div.count(type))
      _vector_fe_face_neighbor[dim][type]->get_div_phi();
  }
}

Referenced by getVectorFEFaceNeighbor().

buildVectorFE()

void Assembly::buildVectorFE ( FEType  type ) const

private

Build Vector FEs with a type.

Parameters

type	The type of FE

Definition at line 478 of file Assembly.C.

{
  if (!_vector_fe_shape_data[type])
    _vector_fe_shape_data[type] = std::make_unique<VectorFEShapeData>();
 
  // Note that NEDELEC_ONE and RAVIART_THOMAS elements can only be built for dimension > 2
  unsigned int min_dim;
  if (type.family == NEDELEC_ONE || type.family == RAVIART_THOMAS ||
      type.family == L2_RAVIART_THOMAS)
    min_dim = 2;
  else
    min_dim = 0;
 
  // Build an FE object for this type for each dimension from the min_dim up to the dimension of the
  // current mesh
  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]->add_p_level_in_reinit(type.p_refinement);
    }
 
    _vector_fe[dim][type]->get_phi();
    _vector_fe[dim][type]->get_dphi();
    if (_need_curl.count(type))
      _vector_fe[dim][type]->get_curl_phi();
    if (_need_div.count(type))
      _vector_fe[dim][type]->get_div_phi();
    _vector_fe[dim][type]->get_xyz();
  }
}

Referenced by getVectorFE().

buildVectorLowerDFE()

void Assembly::buildVectorLowerDFE ( FEType  type ) const

private

Build Vector FEs for a lower dimensional element with a type.

Parameters

type	The type of FE

Definition at line 422 of file Assembly.C.

{
  if (!_vector_fe_shape_data_lower[type])
    _vector_fe_shape_data_lower[type] = std::make_unique<VectorFEShapeData>();
 
  // Build an FE object for this type for each dimension up to the dimension of
  // the current mesh minus one (because this is for lower-dimensional
  // elements!)
  unsigned int dim = ((type.family == LAGRANGE_VEC) || (type.family == MONOMIAL_VEC)) ? 0 : 2;
  const auto ending_dim = cast_int<unsigned int>(_mesh_dimension - 1);
  if (ending_dim < dim)
    return;
  for (; dim <= ending_dim; dim++)
  {
    if (!_vector_fe_lower[dim][type])
    {
      _vector_fe_lower[dim][type] = FEVectorBase::build(dim, type).release();
      _vector_fe_lower[dim][type]->add_p_level_in_reinit(type.p_refinement);
    }
 
    _vector_fe_lower[dim][type]->get_phi();
    _vector_fe_lower[dim][type]->get_dphi();
    if (_need_second_derivative.count(type))
      _vector_fe_lower[dim][type]->get_d2phi();
  }
}

buildVectorNeighborFE()

void Assembly::buildVectorNeighborFE ( FEType  type ) const

private

Build Vector FEs for a neighbor with a type.

Parameters

type	The type of FE

Definition at line 545 of file Assembly.C.

{
  if (!_vector_fe_shape_data_neighbor[type])
    _vector_fe_shape_data_neighbor[type] = std::make_unique<VectorFEShapeData>();
 
  // Note that NEDELEC_ONE and RAVIART_THOMAS elements can only be built for dimension > 2
  unsigned int min_dim;
  if (type.family == NEDELEC_ONE || type.family == RAVIART_THOMAS ||
      type.family == L2_RAVIART_THOMAS)
    min_dim = 2;
  else
    min_dim = 0;
 
  // Build an FE object for this type for each dimension from the min_dim up to the dimension of the
  // current mesh
  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]->add_p_level_in_reinit(type.p_refinement);
    }
 
    _vector_fe_neighbor[dim][type]->get_phi();
    _vector_fe_neighbor[dim][type]->get_dphi();
    if (_need_curl.count(type))
      _vector_fe_neighbor[dim][type]->get_curl_phi();
    if (_need_neighbor_div.count(type))
      _vector_fe_neighbor[dim][type]->get_div_phi();
  }
}

Referenced by getVectorFENeighbor().

bumpAllQRuleOrder()

void Assembly::bumpAllQRuleOrder	(	Order	order,
		SubdomainID	block
	)

Increases the element/volume and face/area quadrature orders for the specified mesh block if and only if the current volume or face quadrature order is lower.

This can only cause the quadrature level to increase. If order is lower than or equal to the current volume+face quadrature rule order, then nothing is done (i.e. this function is idempotent).

Definition at line 635 of file Assembly.C.

{
  auto & qdefault = _qrules[Moose::ANY_BLOCK_ID];
  mooseAssert(qdefault.size() > 0, "default quadrature must be initialized before order bumps");
 
  unsigned int ndims = _mesh_dimension + 1; // must account for 0-dimensional quadrature.
  auto & qvec = _qrules[block];
  if (qvec.size() != ndims || !qvec[0].vol)
    createQRules(qdefault[0].vol->type(), order, order, order, block);
  else if (qvec[0].vol->get_order() < order || qvec[0].face->get_order() < order)
    createQRules(qvec[0].vol->type(),
                 std::max(order, qvec[0].arbitrary_vol->get_order()),
                 std::max(order, qvec[0].vol->get_order()),
                 std::max(order, qvec[0].face->get_order()),
                 block);
  // otherwise do nothing - quadrature order is already as high as requested
}

bumpVolumeQRuleOrder()

void Assembly::bumpVolumeQRuleOrder	(	Order	volume_order,
		SubdomainID	block
	)

Increases the element/volume quadrature order for the specified mesh block if and only if the current volume quadrature order is lower.

This works exactly like the bumpAllQRuleOrder function, except it only affects the volume quadrature rule (not face quadrature).

Definition at line 612 of file Assembly.C.

{
  auto & qdefault = _qrules[Moose::ANY_BLOCK_ID];
  mooseAssert(qdefault.size() > 0, "default quadrature must be initialized before order bumps");
 
  unsigned int ndims = _mesh_dimension + 1; // must account for 0-dimensional quadrature.
  auto & qvec = _qrules[block];
  if (qvec.size() != ndims || !qvec[0].vol)
    createQRules(qdefault[0].vol->type(),
                 qdefault[0].arbitrary_vol->get_order(),
                 volume_order,
                 qdefault[0].face->get_order(),
                 block);
  else if (qvec[0].vol->get_order() < volume_order)
    createQRules(qvec[0].vol->type(),
                 qvec[0].arbitrary_vol->get_order(),
                 volume_order,
                 qvec[0].face->get_order(),
                 block);
  // otherwise do nothing - quadrature order is already as high as requested
}

cacheJacobian() [1/4]

template<typename Residuals , typename Indices >

void Assembly::cacheJacobian	(	const Residuals &	residuals,
		const Indices &	row_indices,
		Real	scaling_factor,
		LocalDataKey	,
		const std::set< TagID > &	matrix_tags
	)

Process the derivatives() data of a vector of ADReals.

This method simply caches the derivative values for the corresponding column indices for the provided matrix_tags. Note that this overload will call DofMap::constrain_element_matrix. Only blessed framework classes may call this API by creating the requisiste LocalDataKey class

Definition at line 3108 of file Assembly.h.

{
  if (!computingJacobian() || matrix_tags.empty())
    return;
 
  // A single row needs no constraining unless its dof or one of its column dofs is constrained, in
  // which case its entries must be distributed to the constraining rows and columns
  const auto & single_row_dofs = residuals[0].derivatives().nude_indices();
  if (residuals.size() == 1 && !_dof_map.is_constrained_dof(input_row_indices[0]) &&
      std::none_of(single_row_dofs.begin(),
                   single_row_dofs.end(),
                   [this](const auto dof) { return _dof_map.is_constrained_dof(dof); }))
  {
    // No constraining is required. (This is likely a finite volume computation if we only have a
    // single dof)
    cacheJacobianWithoutConstraints(
        residuals, input_row_indices, scaling_factor, LocalDataKey{}, matrix_tags);
    return;
  }
 
  const auto & compare_dofs = residuals[0].derivatives().nude_indices();
#ifndef NDEBUG
  auto compare_dofs_set = std::set<dof_id_type>(compare_dofs.begin(), compare_dofs.end());
 
  for (const auto i : make_range(decltype(residuals.size())(1), residuals.size()))
  {
    const auto & residual = residuals[i];
    auto current_dofs_set = std::set<dof_id_type>(residual.derivatives().nude_indices().begin(),
                                                  residual.derivatives().nude_indices().end());
    mooseAssert(compare_dofs_set == current_dofs_set,
                "We're going to see whether the dof sets are the same. IIRC the degree of freedom "
                "dependence (as indicated by the dof index set held by the ADReal) has to be the "
                "same for every residual passed to this method otherwise constrain_element_matrix "
                "will not work.");
  }
#endif
  _column_indices.assign(compare_dofs.begin(), compare_dofs.end());
 
  // If there's no derivatives then there is nothing to do. Moreover, if we pass zero size column
  // indices to constrain_element_matrix then we will potentially get errors out of BLAS
  if (!_column_indices.size())
    return;
 
  // Need to make a copy because we might modify this in constrain_element_matrix
  _row_indices.assign(input_row_indices.begin(), input_row_indices.end());
 
  _element_matrix.resize(_row_indices.size(), _column_indices.size());
  for (const auto i : index_range(_row_indices))
  {
    const auto & sparse_derivatives = residuals[i].derivatives();
 
    for (const auto j : index_range(_column_indices))
      _element_matrix(i, j) = sparse_derivatives[_column_indices[j]] * scaling_factor;
  }
 
  _dof_map.constrain_element_matrix(_element_matrix, _row_indices, _column_indices);
 
  for (const auto i : index_range(_row_indices))
    for (const auto j : index_range(_column_indices))
      cacheJacobian(_row_indices[i], _column_indices[j], _element_matrix(i, j), {}, matrix_tags);
}

cacheJacobian() [2/4]

void Assembly::cacheJacobian

(

GlobalDataKey

)

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

Definition at line 4097 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);
}

Referenced by TaggingInterface::addJacobian(), TaggingInterface::addJacobianElement(), cacheJacobian(), SubProblem::cacheJacobian(), cacheJacobian(), cacheJacobianBlock(), and cacheJacobianWithoutConstraints().

cacheJacobian() [3/4]

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

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

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.

Only blessed framework classes may call this API by creating the requisiste LocalDataKey class

Definition at line 4516 of file Assembly.C.

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

cacheJacobian() [4/4]

void Assembly::cacheJacobian	(	numeric_index_type	i,
		numeric_index_type	j,
		Real	value,
		LocalDataKey	,
		TagID	tag
	)

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.

Only blessed framework classes may call this API by creating the requisiste LocalDataKey class

Definition at line 4507 of file Assembly.C.

{
  _cached_jacobian_rows[tag].push_back(i);
  _cached_jacobian_cols[tag].push_back(j);
  _cached_jacobian_values[tag].push_back(value);
}

cacheJacobianBlock() [1/2]

void Assembly::cacheJacobianBlock ( const DenseMatrix< Number > &  jac_block, const MooseVariableBase &  ivar, const MooseVariableBase &  jvar, const std::vector< dof_id_type > &  idof_indices, const std::vector< dof_id_type > &  jdof_indices, TagID  tag  )

private

Push a local Jacobian block with proper scaling into cache for a certain tag.

Definition at line 3658 of file Assembly.C.

{
  if (idof_indices.size() == 0 || jdof_indices.size() == 0)
    return;
  if (jac_block.n() == 0 || jac_block.m() == 0)
    return;
  if (!_sys.hasMatrix(tag))
    return;
 
  auto & scaling_factors = ivar.arrayScalingFactor();
  const unsigned int iv = ivar.number();
  const unsigned int jv = jvar.number();
 
  for (unsigned int i = 0; i < ivar.count(); ++i)
  {
    for (const auto & jt : libMesh::ConstCouplingRow(iv + i, *_cm))
    {
      if (jt < jv || jt >= jv + jvar.count())
        continue;
      unsigned int j = jt - jv;
 
      auto di = ivar.componentDofIndices(idof_indices, i);
      auto dj = jvar.componentDofIndices(jdof_indices, j);
      auto indof = di.size();
      auto jndof = dj.size();
 
      unsigned int jj = j;
      if (iv == jv && _component_block_diagonal[iv])
        // here i must be equal to j
        jj = 0;
 
      auto sub = jac_block.sub_matrix(i * indof, indof, jj * jndof, jndof);
      if (scaling_factors[i] != 1.0)
        sub *= scaling_factors[i];
 
      // If we're computing the jacobian for automatically scaling variables we do not want
      // to constrain the element matrix because it introduces 1s on the diagonal for the
      // constrained dofs
      if (!_sys.computingScalingJacobian())
        _dof_map.constrain_element_matrix(sub, di, dj, false);
 
      for (MooseIndex(di) i = 0; i < di.size(); i++)
        for (MooseIndex(dj) j = 0; j < dj.size(); j++)
        {
          _cached_jacobian_values[tag].push_back(sub(i, j));
          _cached_jacobian_rows[tag].push_back(di[i]);
          _cached_jacobian_cols[tag].push_back(dj[j]);
        }
    }
  }
}

cacheJacobianBlock() [2/2]

void Assembly::cacheJacobianBlock	(	const DenseMatrix< Number > &	jac_block,
		const std::vector< dof_id_type > &	idof_indices,
		const std::vector< dof_id_type > &	jdof_indices,
		Real	scaling_factor,
		LocalDataKey	,
		const std::set< TagID > &	tags
	)

Cache a local Jacobian block with the provided rows (idof_indices) and columns (jdof_indices) for eventual accumulation into the global matrices specified by tags.

The scaling_factor will be applied before caching. The input block is left unchanged; any constraints and scaling are applied to Assembly's work matrix. Only blessed framework classes may call this API by creating the requisite LocalDataKey class.

Definition at line 3773 of file Assembly.C.

{
  const auto has_matrix =
      std::any_of(tags.begin(), tags.end(), [this](const auto tag) { return _sys.hasMatrix(tag); });
 
  // Work on a reusable Assembly-owned copy so callers retain their local matrix. This also lets us
  // apply constraints and scaling once before caching the same block to every requested matrix tag.
  if ((idof_indices.size() > 0) && (jdof_indices.size() > 0) && jac_block.n() && jac_block.m() &&
      has_matrix)
  {
    _row_indices.assign(idof_indices.begin(), idof_indices.end());
    _column_indices.assign(jdof_indices.begin(), jdof_indices.end());
    _element_matrix = jac_block;
 
    // If we're computing the jacobian for automatically scaling variables we do not want to
    // constrain the element matrix because it introduces 1s on the diagonal for the constrained
    // dofs
    if (!_sys.computingScalingJacobian())
      _dof_map.constrain_element_matrix(_element_matrix, _row_indices, _column_indices, false);
 
    if (scaling_factor != 1.0)
      _element_matrix *= scaling_factor;
 
    for (const auto i : index_range(_row_indices))
      for (const auto j : index_range(_column_indices))
        cacheJacobian(
            _row_indices[i], _column_indices[j], _element_matrix(i, j), LocalDataKey{}, tags);
  }
}

Referenced by TaggingInterface::addJacobian(), cacheJacobianCoupledVarPair(), cacheJacobianMortar(), and cacheJacobianNeighbor().

cacheJacobianBlockNonzero()

void Assembly::cacheJacobianBlockNonzero ( const DenseMatrix< Number > &  jac_block, const MooseVariableBase &  ivar, const MooseVariableBase &  jvar, const std::vector< dof_id_type > &  idof_indices, const std::vector< dof_id_type > &  jdof_indices, TagID  tag  )

private

Push non-zeros of a local Jacobian block with proper scaling into cache for a certain tag.

Definition at line 3717 of file Assembly.C.

{
  if (idof_indices.size() == 0 || jdof_indices.size() == 0)
    return;
  if (jac_block.n() == 0 || jac_block.m() == 0)
    return;
  if (!_sys.hasMatrix(tag))
    return;
 
  auto & scaling_factor = ivar.arrayScalingFactor();
 
  for (unsigned int i = 0; i < ivar.count(); ++i)
  {
    unsigned int iv = ivar.number();
    for (const auto & jt : libMesh::ConstCouplingRow(iv + i, *_cm))
    {
      unsigned int jv = jvar.number();
      if (jt < jv || jt >= jv + jvar.count())
        continue;
      unsigned int j = jt - jv;
 
      auto di = ivar.componentDofIndices(idof_indices, i);
      auto dj = jvar.componentDofIndices(jdof_indices, j);
      auto indof = di.size();
      auto jndof = dj.size();
 
      unsigned int jj = j;
      if (iv == jv && _component_block_diagonal[iv])
        // here i must be equal to j
        jj = 0;
 
      auto sub = jac_block.sub_matrix(i * indof, indof, jj * jndof, jndof);
      if (scaling_factor[i] != 1.0)
        sub *= scaling_factor[i];
 
      _dof_map.constrain_element_matrix(sub, di, dj, false);
 
      for (MooseIndex(di) i = 0; i < di.size(); i++)
        for (MooseIndex(dj) j = 0; j < dj.size(); j++)
          if (sub(i, j) != 0.0) // no storage allocated for unimplemented jacobian terms,
                                // maintaining maximum sparsity possible
          {
            _cached_jacobian_values[tag].push_back(sub(i, j));
            _cached_jacobian_rows[tag].push_back(di[i]);
            _cached_jacobian_cols[tag].push_back(dj[j]);
          }
    }
  }
}

Referenced by cacheJacobianNonlocal().

cacheJacobianCoupledVarPair()

void Assembly::cacheJacobianCoupledVarPair ( const MooseVariableBase &  ivar, const MooseVariableBase &  jvar  )

private

Caches element matrix for ivar rows and jvar columns.

Definition at line 4111 of file Assembly.C.

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

Referenced by cacheJacobian().

cacheJacobianMortar()

void Assembly::cacheJacobianMortar

(

GlobalDataKey

)

Cache all portions of the Jacobian, e.g.

LowerLower, LowerSecondary, LowerPrimary, SecondaryLower, SecondarySecondary, SecondaryPrimary, PrimaryLower, PrimarySecondary, PrimaryPrimary for mortar-like objects. Primary indicates the interior parent element on the primary side of the mortar interface. Secondary indicates the interior parent element on the secondary side of the interface. Lower denotes the lower-dimensional element living on the secondary side of the mortar interface; it's the boundary face of the Secondary element.

Definition at line 4187 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_lower_used) tag = 0; tag < _jacobian_block_lower_used.size();
         tag++)
      if (jacobianBlockLowerUsed(tag, i, j) && _sys.hasMatrix(tag))
      {
        cacheJacobianBlock(jacobianBlockMortar(Moose::LowerLower, i, j, LocalDataKey{}, tag),
                           *ivar,
                           *jvar,
                           ivar->dofIndicesLower(),
                           jvar->dofIndicesLower(),
                           tag);
 
        cacheJacobianBlock(jacobianBlockMortar(Moose::LowerSecondary, i, j, LocalDataKey{}, tag),
                           *ivar,
                           *jvar,
                           ivar->dofIndicesLower(),
                           jvar->dofIndices(),
                           tag);
 
        cacheJacobianBlock(jacobianBlockMortar(Moose::LowerPrimary, i, j, LocalDataKey{}, tag),
                           *ivar,
                           *jvar,
                           ivar->dofIndicesLower(),
                           jvar->dofIndicesNeighbor(),
                           tag);
 
        cacheJacobianBlock(jacobianBlockMortar(Moose::SecondaryLower, i, j, LocalDataKey{}, tag),
                           *ivar,
                           *jvar,
                           ivar->dofIndices(),
                           jvar->dofIndicesLower(),
                           tag);
 
        cacheJacobianBlock(
            jacobianBlockMortar(Moose::SecondarySecondary, i, j, LocalDataKey{}, tag),
            *ivar,
            *jvar,
            ivar->dofIndices(),
            jvar->dofIndices(),
            tag);
 
        cacheJacobianBlock(jacobianBlockMortar(Moose::SecondaryPrimary, i, j, LocalDataKey{}, tag),
                           *ivar,
                           *jvar,
                           ivar->dofIndices(),
                           jvar->dofIndicesNeighbor(),
                           tag);
 
        cacheJacobianBlock(jacobianBlockMortar(Moose::PrimaryLower, i, j, LocalDataKey{}, tag),
                           *ivar,
                           *jvar,
                           ivar->dofIndicesNeighbor(),
                           jvar->dofIndicesLower(),
                           tag);
 
        cacheJacobianBlock(jacobianBlockMortar(Moose::PrimarySecondary, i, j, LocalDataKey{}, tag),
                           *ivar,
                           *jvar,
                           ivar->dofIndicesNeighbor(),
                           jvar->dofIndices(),
                           tag);
 
        cacheJacobianBlock(jacobianBlockMortar(Moose::PrimaryPrimary, i, j, LocalDataKey{}, tag),
                           *ivar,
                           *jvar,
                           ivar->dofIndicesNeighbor(),
                           jvar->dofIndicesNeighbor(),
                           tag);
      }
  }
}

Referenced by ComputeMortarFunctor::operator()().

cacheJacobianNeighbor()

void Assembly::cacheJacobianNeighbor

(

GlobalDataKey

)

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

Definition at line 4149 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 (jacobianBlockNeighborUsed(tag, i, j) && _sys.hasMatrix(tag))
      {
        cacheJacobianBlock(jacobianBlockNeighbor(Moose::ElementNeighbor, i, j, LocalDataKey{}, tag),
                           *ivar,
                           *jvar,
                           ivar->dofIndices(),
                           jvar->dofIndicesNeighbor(),
                           tag);
        cacheJacobianBlock(jacobianBlockNeighbor(Moose::NeighborElement, i, j, LocalDataKey{}, tag),
                           *ivar,
                           *jvar,
                           ivar->dofIndicesNeighbor(),
                           jvar->dofIndices(),
                           tag);
        cacheJacobianBlock(
            jacobianBlockNeighbor(Moose::NeighborNeighbor, i, j, LocalDataKey{}, tag),
            *ivar,
            *jvar,
            ivar->dofIndicesNeighbor(),
            jvar->dofIndicesNeighbor(),
            tag);
      }
  }
}

Referenced by SubProblem::cacheJacobianNeighbor().

cacheJacobianNonlocal()

void Assembly::cacheJacobianNonlocal

(

GlobalDataKey

)

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

Definition at line 4127 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 (jacobianBlockNonlocalUsed(tag, i, j) && _sys.hasMatrix(tag))
        cacheJacobianBlockNonzero(jacobianBlockNonlocal(i, j, LocalDataKey{}, tag),
                                  *ivar,
                                  *jvar,
                                  ivar->dofIndices(),
                                  jvar->allDofIndices(),
                                  tag);
  }
}

Referenced by SubProblem::cacheJacobian().

cacheJacobianWithoutConstraints()

template<typename Residuals , typename Indices >

void Assembly::cacheJacobianWithoutConstraints	(	const Residuals &	residuals,
		const Indices &	row_indices,
		Real	scaling_factor,
		LocalDataKey	,
		const std::set< TagID > &	matrix_tags
	)

Process the derivatives() data of a vector of ADReals.

This method simply caches the derivative values for the corresponding column indices for the provided matrix_tags. Note that this overload will \emph not call DofMap::constrain_element_matrix. Only blessed framework classes may call this API by creating the requisiste LocalDataKey class

Definition at line 3176 of file Assembly.h.

{
  mooseAssert(residuals.size() == row_indices.size(),
              "The number of residuals should match the number of dof indices");
  mooseAssert(residuals.size() >= 1, "Why you calling me with no residuals?");
 
  if (!computingJacobian() || matrix_tags.empty())
    return;
 
  for (const auto i : index_range(row_indices))
  {
    const auto row_index = row_indices[i];
 
    const auto & sparse_derivatives = residuals[i].derivatives();
    const auto & column_indices = sparse_derivatives.nude_indices();
    const auto & raw_derivatives = sparse_derivatives.nude_data();
 
    for (std::size_t j = 0; j < column_indices.size(); ++j)
      cacheJacobian(
          row_index, column_indices[j], raw_derivatives[j] * scaling_factor, {}, matrix_tags);
  }
}

Referenced by TaggingInterface::addJacobianWithoutConstraints(), and cacheJacobian().

cacheResidual() [1/3]

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

private

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 these tags

Definition at line 3469 of file Assembly.C.

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

cacheResidual() [2/3]

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

private

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 this tagged residual

Definition at line 3459 of file Assembly.C.

{
  const VectorTag & tag = _subproblem.getVectorTag(tag_id);
 
  _cached_residual_values[tag._type_id].push_back(value);
  _cached_residual_rows[tag._type_id].push_back(dof);
}

cacheResidual() [3/3]

void Assembly::cacheResidual	(	GlobalDataKey	,
		const std::vector< VectorTag > &	tags
	)

Takes the values that are currently in _sub_Re of all field variables and appends them to the cached values.

Definition at line 3444 of file Assembly.C.

{
  const std::vector<MooseVariableFEBase *> & vars = _sys.getVariables(_tid);
  for (const auto & var : vars)
    for (const auto & vector_tag : tags)
      if (_sys.hasVector(vector_tag._id))
        cacheResidualBlock(_cached_residual_values[vector_tag._type_id],
                           _cached_residual_rows[vector_tag._type_id],
                           _sub_Re[vector_tag._type_id][var->number()],
                           var->dofIndices(),
                           var->arrayScalingFactor());
}

Referenced by SubProblem::cacheResidual(), cacheResidual(), cacheResiduals(), cacheResidualsWithoutConstraints(), and ComputeMortarFunctor::operator()().

cacheResidualBlock()

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

private

Push a local residual block with proper scaling into cache.

Definition at line 3318 of file Assembly.C.

{
  if (dof_indices.size() > 0 && res_block.size())
  {
    _temp_dof_indices = dof_indices;
    _tmp_Re = res_block;
    processLocalResidual(_tmp_Re, _temp_dof_indices, 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]);
    }
  }
 
  res_block.zero();
}

Referenced by cacheResidual(), cacheResidualLower(), and cacheResidualNeighbor().

cacheResidualLower()

void Assembly::cacheResidualLower	(	GlobalDataKey	,
		const std::vector< VectorTag > &	tags
	)

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

Definition at line 3508 of file Assembly.C.

{
  const std::vector<MooseVariableFEBase *> & vars = _sys.getVariables(_tid);
  for (const auto & var : vars)
    for (const auto & vector_tag : tags)
      if (_sys.hasVector(vector_tag._id))
        cacheResidualBlock(_cached_residual_values[vector_tag._type_id],
                           _cached_residual_rows[vector_tag._type_id],
                           _sub_Rl[vector_tag._type_id][var->number()],
                           var->dofIndicesLower(),
                           var->arrayScalingFactor());
}

Referenced by ComputeMortarFunctor::operator()().

cacheResidualNeighbor()

void Assembly::cacheResidualNeighbor	(	GlobalDataKey	,
		const std::vector< VectorTag > &	tags
	)

Takes the values that are currently in _sub_Rn of all field variables and appends them to the cached values.

Definition at line 3494 of file Assembly.C.

{
  const std::vector<MooseVariableFEBase *> & vars = _sys.getVariables(_tid);
  for (const auto & var : vars)
    for (const auto & vector_tag : tags)
      if (_sys.hasVector(vector_tag._id))
        cacheResidualBlock(_cached_residual_values[vector_tag._type_id],
                           _cached_residual_rows[vector_tag._type_id],
                           _sub_Rn[vector_tag._type_id][var->number()],
                           var->dofIndicesNeighbor(),
                           var->arrayScalingFactor());
}

Referenced by SubProblem::cacheResidualNeighbor(), and ComputeMortarFunctor::operator()().

cacheResidualNodes()

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

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

Only blessed framework classes may call this API by creating the requisiste LocalDataKey class

Definition at line 3476 of file Assembly.C.

{
  // 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 primary and secondary
  // node.
  const VectorTag & vector_tag = _subproblem.getVectorTag(tag);
  for (MooseIndex(dof_index) i = 0; i < dof_index.size(); ++i)
  {
    _cached_residual_values[vector_tag._type_id].push_back(res(i));
    _cached_residual_rows[vector_tag._type_id].push_back(dof_index[i]);
  }
}

cacheResiduals()

template<typename Residuals , typename Indices >

void Assembly::cacheResiduals	(	const Residuals &	residuals,
		const Indices &	row_indices,
		Real	scaling_factor,
		LocalDataKey	,
		const std::set< TagID > &	vector_tags
	)

Process the supplied residual values.

This is a mirror of of the non-templated version of addResiduals except that it's meant for \emph only processing residuals (and not their derivatives/Jacobian). We supply this API such that residual objects that leverage the AD version of this method when computing the Jacobian (or residual + Jacobian) can mirror the same behavior when doing pure residual evaluations, such as when evaluating linear residuals during (P)JFNK. This method will call constrain_element_vector on the supplied residuals. Only blessed framework classes may call this API by creating the requisiste LocalDataKey class

Definition at line 3047 of file Assembly.h.

{
  mooseAssert(residuals.size() == input_row_indices.size(),
              "The number of residuals should match the number of dof indices");
  mooseAssert(residuals.size() >= 1, "Why you calling me with no residuals?");
 
  if (!computingResidual() || vector_tags.empty())
    return;
 
  // A single row needs no constraining unless its dof is constrained (e.g. by a periodic boundary,
  // a hanging node, or a user constraint), in which case its residual must be distributed to the
  // constraining dofs
  if (residuals.size() == 1 && !_dof_map.is_constrained_dof(input_row_indices[0]))
  {
    // No constraining is required. (This is likely a finite volume computation if we only have a
    // single dof)
    cacheResidualsWithoutConstraints(
        residuals, input_row_indices, scaling_factor, LocalDataKey{}, vector_tags);
    return;
  }
 
  // Need to make a copy because we might modify this in constrain_element_vector
  _row_indices.assign(input_row_indices.begin(), input_row_indices.end());
 
  _element_vector.resize(_row_indices.size());
  for (const auto i : index_range(_row_indices))
    _element_vector(i) = MetaPhysicL::raw_value(residuals[i]) * scaling_factor;
 
  // At time of writing, this method doesn't do anything with the asymmetric_constraint_rows
  // argument, but we set it to false to be consistent with processLocalResidual
  _dof_map.constrain_element_vector(
      _element_vector, _row_indices, /*asymmetric_constraint_rows=*/false);
 
  for (const auto i : index_range(_row_indices))
    cacheResidual(_row_indices[i], _element_vector(i), vector_tags);
}

Referenced by TaggingInterface::addResiduals().

cacheResidualsWithoutConstraints()

template<typename Residuals , typename Indices >

void Assembly::cacheResidualsWithoutConstraints	(	const Residuals &	residuals,
		const Indices &	row_indices,
		Real	scaling_factor,
		LocalDataKey	,
		const std::set< TagID > &	vector_tags
	)

Process the supplied residual values.

This is a mirror of of the non-templated version of addResiduals except that it's meant for \emph only processing residuals (and not their derivatives/Jacobian). We supply this API such that residual objects that leverage the AD version of this method when computing the Jacobian (or residual + Jacobian) can mirror the same behavior when doing pure residual evaluations, such as when evaluating linear residuals during (P)JFNK. This method will \emph not call constrain_element_vector on the supplied residuals. Only blessed framework classes may call this API by creating the requisiste LocalDataKey class

Definition at line 3090 of file Assembly.h.

{
  mooseAssert(residuals.size() == row_indices.size(),
              "The number of residuals should match the number of dof indices");
  mooseAssert(residuals.size() >= 1, "Why you calling me with no residuals?");
 
  if (computingResidual() && !vector_tags.empty())
    for (const auto i : index_range(row_indices))
      cacheResidual(
          row_indices[i], MetaPhysicL::raw_value(residuals[i]) * scaling_factor, vector_tags);
}

Referenced by TaggingInterface::addResidualsWithoutConstraints(), and cacheResiduals().

clearCachedJacobian()

void Assembly::clearCachedJacobian ( )

private

Clear any currently cached jacobians.

This is automatically called by setCachedJacobian

Definition at line 4558 of file Assembly.C.

{
  for (MooseIndex(_cached_jacobian_rows) tag = 0; tag < _cached_jacobian_rows.size(); tag++)
  {
    _cached_jacobian_rows[tag].clear();
    _cached_jacobian_cols[tag].clear();
    _cached_jacobian_values[tag].clear();
  }
}

Referenced by setCachedJacobian(), and zeroCachedJacobian().

clearCachedQRules()

void Assembly::clearCachedQRules

(

)

Set the cached quadrature rules to nullptr.

Definition at line 763 of file Assembly.C.

{
  _current_qrule = nullptr;
  _current_qrule_face = nullptr;
  _current_qrule_lower = nullptr;
  _current_qrule_neighbor = nullptr;
}

clearCachedResiduals() [1/2]

void Assembly::clearCachedResiduals ( const VectorTag &  vector_tag )

private

Clears all of the cached residuals for a specific vector tag.

Definition at line 3545 of file Assembly.C.

{
  auto & values = _cached_residual_values[vector_tag._type_id];
  auto & rows = _cached_residual_rows[vector_tag._type_id];
 
  mooseAssert(values.size() == rows.size(),
              "Number of cached residuals and number of rows must match!");
 
  // Keep track of the largest size so we can use it to reserve and avoid
  // as much dynamic allocation as possible
  if (_max_cached_residuals < values.size())
    _max_cached_residuals = values.size();
 
  // Clear both vectors (keeps the capacity the same)
  values.clear();
  rows.clear();
  // And then reserve: use 2 as a fudge factor to *really* avoid dynamic allocation!
  values.reserve(_max_cached_residuals * 2);
  rows.reserve(_max_cached_residuals * 2);
}

clearCachedResiduals() [2/2]

void Assembly::clearCachedResiduals

(

GlobalDataKey

)

Clears all of the residuals in _cached_residual_rows and _cached_residual_values.

This method is designed specifically for use after calling FEProblemBase::addCachedResidualDirectly() and DisplacedProblem::addCachedResidualDirectly() to ensure that we don't have any extra residuals hanging around that we didn't have the vectors for

Definition at line 3537 of file Assembly.C.

{
  for (const auto & vector_tag : _residual_vector_tags)
    clearCachedResiduals(vector_tag);
}

Referenced by addCachedResidualDirectly(), and clearCachedResiduals().

computeADFace()

void Assembly::computeADFace ( const Elem &  elem, const unsigned int  side  )

private

compute AD things on an element face

Definition at line 2159 of file Assembly.C.

{
  const auto dim = elem.dim();
 
  if (_subproblem.haveADObjects())
  {
    auto n_qp = _current_qrule_face->n_points();
    resizeADMappingObjects(n_qp, dim);
    _ad_normals.resize(n_qp);
    _ad_JxW_face.resize(n_qp);
    if (_calculate_face_xyz)
      _ad_q_points_face.resize(n_qp);
    if (_calculate_curvatures)
      _ad_curvatures.resize(n_qp);
 
    if (_displaced)
    {
      const auto & qw = _current_qrule_face->get_weights();
      computeFaceMap(elem, side, qw);
      const std::vector<Real> dummy_qw(n_qp, 1.);
 
      for (unsigned int qp = 0; qp != n_qp; qp++)
        computeSinglePointMapAD(&elem, dummy_qw, qp, _holder_fe_face_helper[dim]);
    }
    else
    {
      for (unsigned qp = 0; qp < n_qp; ++qp)
      {
        _ad_JxW_face[qp] = _current_JxW_face[qp];
        _ad_normals[qp] = _current_normals[qp];
      }
      if (_calculate_face_xyz)
        for (unsigned qp = 0; qp < n_qp; ++qp)
          _ad_q_points_face[qp] = _current_q_points_face[qp];
      if (_calculate_curvatures)
        for (unsigned qp = 0; qp < n_qp; ++qp)
          _ad_curvatures[qp] = _curvatures[qp];
    }
 
    if (_need_ad_grad_phi_face)
    {
      for (const auto & it : _fe_face[dim])
      {
        FEBase & fe = *it.second;
        auto fe_type = it.first;
        auto num_shapes = FEInterface::n_shape_functions(fe_type, &elem);
        auto & grad_phi = _ad_grad_phi_data_face[fe_type];
 
        grad_phi.resize(num_shapes);
        for (decltype(num_shapes) i = 0; i < num_shapes; ++i)
          grad_phi[i].resize(n_qp);
 
        const auto & regular_grad_phi = _fe_shape_data_face[fe_type]->_grad_phi;
 
        if (_displaced)
          computeGradPhiAD(&elem, n_qp, grad_phi, &fe);
        else
          for (decltype(num_shapes) i = 0; i < num_shapes; ++i)
            for (unsigned qp = 0; qp < n_qp; ++qp)
              grad_phi[i][qp] = regular_grad_phi[i][qp];
      }
      for (const auto & it : _vector_fe_face[dim])
      {
        FEVectorBase & fe = *it.second;
        auto fe_type = it.first;
        auto num_shapes = FEInterface::n_shape_functions(fe_type, &elem);
        auto & grad_phi = _ad_vector_grad_phi_data_face[fe_type];
 
        grad_phi.resize(num_shapes);
        for (decltype(num_shapes) i = 0; i < num_shapes; ++i)
          grad_phi[i].resize(n_qp);
 
        const auto & regular_grad_phi = _vector_fe_shape_data_face[fe_type]->_grad_phi;
 
        if (_displaced)
          computeGradPhiAD(&elem, n_qp, grad_phi, &fe);
        else
          for (decltype(num_shapes) i = 0; i < num_shapes; ++i)
            for (unsigned qp = 0; qp < n_qp; ++qp)
              grad_phi[i][qp] = regular_grad_phi[i][qp];
      }
    }
  }
}

Referenced by reinitElemFaceRef(), and reinitFEFace().

computeCurrentElemVolume()

void Assembly::computeCurrentElemVolume ( )

private

Definition at line 1793 of file Assembly.C.

{
  if (_current_elem_volume_computed)
    return;
 
  setCoordinateTransformation(
      _current_qrule, _current_q_points, _coord, _current_elem->subdomain_id());
  if (_calculate_ad_coord)
    setCoordinateTransformation(
        _current_qrule, _ad_q_points, _ad_coord, _current_elem->subdomain_id());
 
  _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;
}

Referenced by reinit(), and reinit().

computeCurrentFaceVolume()

void Assembly::computeCurrentFaceVolume ( )

private

Definition at line 1812 of file Assembly.C.

{
  if (_current_side_volume_computed)
    return;
 
  setCoordinateTransformation(
      _current_qrule_face, _current_q_points_face, _coord, _current_elem->subdomain_id());
  if (_calculate_ad_coord)
    setCoordinateTransformation(
        _current_qrule_face, _ad_q_points_face, _ad_coord, _current_elem->subdomain_id());
 
  _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;
}

Referenced by reinit(), reinit(), and reinitElemFaceRef().

computeCurrentNeighborVolume()

void Assembly::computeCurrentNeighborVolume ( )

private

computeFaceMap()

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

private

Definition at line 1387 of file Assembly.C.

{
  // Important quantities calculated by this method:
  //   - _ad_JxW_face
  //   - _ad_q_points_face
  //   - _ad_normals
  //   - _ad_curvatures
 
  const Elem & side_elem = _compute_face_map_side_elem_builder(elem, side);
  const auto dim = elem.dim();
  const auto n_qp = qw.size();
  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;
  const auto sys_num = _sys.number();
  const bool do_derivatives = ADReal::do_derivatives && sys_num == _subproblem.currentNlSysNum();
 
  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_elem.node_id(0) == elem.node_id(0))
        _ad_normals[0] = Point(-1.);
      else
        _ad_normals[0] = Point(1.);
 
      VectorValue<ADReal> side_point;
      if (_calculate_face_xyz)
      {
        const Node & node = side_elem.node_ref(0);
        side_point = node;
 
        if (do_derivatives)
          for (const auto & [disp_num, direction] : _disp_numbers_and_directions)
            Moose::derivInsert(
                side_point(direction).derivatives(), node.dof_number(sys_num, disp_num, 0), 1.);
      }
 
      for (const auto p : make_range(n_qp))
      {
        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 (const auto p : make_range(n_qp))
        _ad_dxyzdxi_map[p].zero();
      if (_calculate_face_xyz)
        for (const auto p : make_range(n_qp))
          _ad_q_points_face[p].zero();
      if (_calculate_curvatures)
        for (const auto p : make_range(n_qp))
          _ad_d2xyzdxi2_map[p].zero();
 
      const auto n_mapping_shape_functions =
          libMesh::FE<2, LAGRANGE>::n_dofs(&side_elem, side_elem.default_order());
 
      for (unsigned int i = 0; i < n_mapping_shape_functions; i++)
      {
        const Node & node = side_elem.node_ref(i);
        VectorValue<ADReal> side_point = node;
 
        if (do_derivatives)
          for (const auto & [disp_num, direction] : _disp_numbers_and_directions)
            Moose::derivInsert(
                side_point(direction).derivatives(), node.dof_number(sys_num, disp_num, 0), 1.);
 
        for (const auto p : make_range(n_qp))
          _ad_dxyzdxi_map[p].add_scaled(side_point, dpsidxi_map[i][p]);
        if (_calculate_face_xyz)
          for (const auto p : make_range(n_qp))
            _ad_q_points_face[p].add_scaled(side_point, psi_map[i][p]);
        if (_calculate_curvatures)
          for (const auto p : make_range(n_qp))
            _ad_d2xyzdxi2_map[p].add_scaled(side_point, (*d2psidxi2_map)[i][p]);
      }
 
      for (const auto p : make_range(n_qp))
      {
        _ad_normals[p] =
            (VectorValue<ADReal>(_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 (const auto p : make_range(n_qp))
      {
        _ad_dxyzdxi_map[p].zero();
        _ad_dxyzdeta_map[p].zero();
      }
      if (_calculate_face_xyz)
        for (const auto p : make_range(n_qp))
          _ad_q_points_face[p].zero();
      if (_calculate_curvatures)
        for (const auto p : make_range(n_qp))
        {
          _ad_d2xyzdxi2_map[p].zero();
          _ad_d2xyzdxideta_map[p].zero();
          _ad_d2xyzdeta2_map[p].zero();
        }
 
      const unsigned int n_mapping_shape_functions =
          libMesh::FE<3, LAGRANGE>::n_dofs(&side_elem, side_elem.default_order());
 
      for (unsigned int i = 0; i < n_mapping_shape_functions; i++)
      {
        const Node & node = side_elem.node_ref(i);
        VectorValue<ADReal> side_point = node;
 
        if (do_derivatives)
          for (const auto & [disp_num, direction] : _disp_numbers_and_directions)
            Moose::derivInsert(
                side_point(direction).derivatives(), node.dof_number(sys_num, disp_num, 0), 1.);
 
        for (const auto p : make_range(n_qp))
        {
          _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)
          for (const auto p : make_range(n_qp))
            _ad_q_points_face[p].add_scaled(side_point, psi_map[i][p]);
        if (_calculate_curvatures)
          for (const auto p : make_range(n_qp))
          {
            _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 (const auto p : make_range(n_qp))
      {
        _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);
 
        using std::sqrt;
        const auto the_jac = 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);
  }
}

Referenced by computeADFace().

computeGradPhiAD() [1/2]

template<typename OutputType >

void Assembly::computeGradPhiAD	(	const Elem *	elem,
		unsigned int	n_qp,
		ADTemplateVariablePhiGradient< OutputType > &	grad_phi,
		FEGenericBase< OutputType > *	fe
	)

Definition at line 928 of file Assembly.C.

{
  // This function relies on the fact that FE::reinit has already been called. FE::reinit will
  // importantly have already called FEMap::init_shape_functions which will have computed
  // these quantities at the integration/quadrature points: dphidxi,
  // dphideta, and dphidzeta (e.g. \nabla phi w.r.t. reference coordinates). These *phi* quantities
  // are independent of mesh displacements when using a quadrature rule.
  //
  // Note that a user could have specified custom integration points (e.g. independent of a
  // quadrature rule) which could very well depend on displacements. In that case even the *phi*
  // quantities from the above paragraph would be a function of the displacements and we would be
  // missing that derivative information in the calculations below
 
  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].slice(0) = dphidxi[i][qp] * _ad_dxidx_map[qp];
          grad_phi[i][qp].slice(1) = dphidxi[i][qp] * _ad_dxidy_map[qp];
          grad_phi[i][qp].slice(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].slice(0) =
              dphidxi[i][qp] * _ad_dxidx_map[qp] + dphideta[i][qp] * _ad_detadx_map[qp];
          grad_phi[i][qp].slice(1) =
              dphidxi[i][qp] * _ad_dxidy_map[qp] + dphideta[i][qp] * _ad_detady_map[qp];
          grad_phi[i][qp].slice(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].slice(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].slice(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].slice(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<typename OutputType >

void Assembly::computeGradPhiAD ( const Elem *  elem, unsigned int  n_qp, ADTemplateVariablePhiGradient< OutputType > &  grad_phi, libMesh::FEGenericBase< OutputType > *  fe  )

private

compute gradient of phi possibly with derivative information with respect to nonlinear displacement variables

Referenced by computeADFace(), and reinitFE().

computeSinglePointMapAD()

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

private

compute the finite element reference-physical mapping quantities (such as JxW) with possible dependence on nonlinear displacement variables at a single quadrature point

Definition at line 1038 of file Assembly.C.

{
  // This function relies on the fact that FE::reinit has already been called. FE::reinit will
  // importantly have already called FEMap::init_reference_to_physical_map which will have computed
  // these quantities at the integration/quadrature points: phi_map, dphidxi_map,
  // dphideta_map, and dphidzeta_map (e.g. phi and \nabla phi w.r.t reference coordinates). *_map is
  // used to denote that quantities are in reference to a mapping Lagrange FE object. The FE<Dim,
  // LAGRANGE> objects used for mapping will in general have an order matching the order of the
  // mesh. These *phi*_map quantities are independent of mesh displacements when using a quadrature
  // rule.
  //
  // Note that a user could have specified custom integration points (e.g. independent of a
  // quadrature rule) which could very well depend on displacements. In that case even the *phi*_map
  // quantities from the above paragraph would be a function of the displacements and we would be
  // missing that derivative information in the calculations below
  //
  // Important quantities calculated by this method:
  //   - _ad_JxW;
  //   - _ad_q_points;
  // And the following quantities are important because they are used in the computeGradPhiAD method
  // to calculate the shape function gradients with respect to the physical coordinates
  // dphi/dphys = dphi/dref * dref/dphys:
  //   - _ad_dxidx_map;
  //   - _ad_dxidy_map;
  //   - _ad_dxidz_map;
  //   - _ad_detadx_map;
  //   - _ad_detady_map;
  //   - _ad_detadz_map;
  //   - _ad_dzetadx_map;
  //   - _ad_dzetady_map;
  //   - _ad_dzetadz_map;
  //
  // Some final notes. This method will be called both when we are reinit'ing in the volume and on
  // faces. When reinit'ing on faces, computation of _ad_JxW will be garbage because we will be
  // using dummy quadrature weights. _ad_q_points computation is also currently extraneous during
  // face reinit because we compute _ad_q_points_face in the computeFaceMap method. However,
  // computation of dref/dphys is absolutely necessary (and the reason we call this method for the
  // face case) for both volume and face reinit
 
  auto dim = elem->dim();
  const auto & elem_nodes = elem->get_nodes();
  const auto & phi_map = fe->get_fe_map().get_phi_map();
  // The mapping basis includes every mapping node, including enriched nodes on elements such as
  // TET14.
  const auto num_shapes = phi_map.size();
  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();
  const auto sys_num = _sys.number();
  const bool do_derivatives =
      ADReal::do_derivatives && _sys.number() == _subproblem.currentNlSysNum();
 
  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]);
        const Node & node = *elem_nodes[i];
        libMesh::VectorValue<ADReal> elem_point = node;
        if (do_derivatives)
          for (const auto & [disp_num, direction] : _disp_numbers_and_directions)
            if (node.n_dofs(sys_num, disp_num))
              Moose::derivInsert(
                  elem_point(direction).derivatives(), node.dof_number(sys_num, disp_num, 0), 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]);
        const Node & node = *elem_nodes[i];
        libMesh::VectorValue<ADReal> elem_point = node;
        if (do_derivatives)
          for (const auto & [disp_num, direction] : _disp_numbers_and_directions)
            if (node.n_dofs(sys_num, disp_num))
              Moose::derivInsert(
                  elem_point(direction).derivatives(), node.dof_number(sys_num, disp_num, 0), 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;
      using std::sqrt;
      _ad_jac[p] = 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]);
        const Node & node = *elem_nodes[i];
        libMesh::VectorValue<ADReal> elem_point = node;
        if (do_derivatives)
          for (const auto & [disp_num, direction] : _disp_numbers_and_directions)
            if (node.n_dofs(sys_num, disp_num))
              Moose::derivInsert(
                  elem_point(direction).derivatives(), node.dof_number(sys_num, disp_num, 0), 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);
  }
}

Referenced by computeADFace(), and reinitFE().

computingJacobian()

bool Assembly::computingJacobian ( ) const

inline

Returns

whether we are computing a Jacobian

Definition at line 1943 of file Assembly.h.

{ return _computing_jacobian; }

Referenced by cacheJacobian(), cacheJacobianWithoutConstraints(), and MortarConstraintBase::zeroInactiveLMDofs().

computingResidual()

bool Assembly::computingResidual ( ) const

inline

Returns

whether we are computing a residual

Definition at line 1938 of file Assembly.h.

{ return _computing_residual; }

Referenced by cacheResiduals(), cacheResidualsWithoutConstraints(), ComputeMortarFunctor::operator()(), and MortarConstraintBase::zeroInactiveLMDofs().

computingResidualAndJacobian()

bool Assembly::computingResidualAndJacobian ( ) const

inline

Returns

whether we are computing a residual and a Jacobian simultaneously

Definition at line 1948 of file Assembly.h.

{ return _computing_residual_and_jacobian; }

constify_ref()

template<typename T >

static const T *const & Assembly::constify_ref ( T *const &  inref )

inlinestatic

Workaround for C++ compilers thinking they can't just cast a const-reference-to-pointer to const-reference-to-const-pointer.

Definition at line 112 of file Assembly.h.

  {
    const T * const * ptr = &inref;
    return *ptr;
  }

Referenced by getFE(), getFEFace(), getFEFaceNeighbor(), getFENeighbor(), getVectorFE(), getVectorFEFace(), getVectorFEFaceNeighbor(), getVectorFENeighbor(), qRule(), qRuleFace(), qRuleMortar(), and qRuleNeighbor().

coordSystem()

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

inline

Get the coordinate system type.

Returns

A reference to the coordinate system type

Definition at line 308 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 280 of file Assembly.h.

{ return _coord; }

copyFaceShapes() [1/2]

template<typename T >

void Assembly::copyFaceShapes

(

MooseVariableField< T > &

v

)

Definition at line 3092 of file Assembly.C.

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

Referenced by copyFaceShapes().

copyFaceShapes() [2/2]

void Assembly::copyFaceShapes

(

unsigned int

var

)

Definition at line 3101 of file Assembly.C.

{
  auto & v = _sys.getVariable(_tid, var);
  if (v.fieldType() == Moose::VarFieldType::VAR_FIELD_STANDARD)
  {
    auto & v = _sys.getActualFieldVariable<Real>(_tid, var);
    copyFaceShapes(v);
  }
  else if (v.fieldType() == Moose::VarFieldType::VAR_FIELD_ARRAY)
  {
    auto & v = _sys.getActualFieldVariable<RealEigenVector>(_tid, var);
    copyFaceShapes(v);
  }
  else if (v.fieldType() == Moose::VarFieldType::VAR_FIELD_VECTOR)
  {
    auto & v = _sys.getActualFieldVariable<RealVectorValue>(_tid, var);
    copyFaceShapes(v);
    if (v.computingCurl())
      _vector_curl_phi_face.shallowCopy(v.curlPhi());
    if (v.computingDiv())
      _vector_div_phi_face.shallowCopy(v.divPhi());
  }
  else
    mooseError("Unsupported variable field type!");
}

copyNeighborShapes() [1/2]

template<typename T >

void Assembly::copyNeighborShapes

(

MooseVariableField< T > &

v

)

Definition at line 3129 of file Assembly.C.

{
  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());
  }
}

Referenced by copyNeighborShapes().

copyNeighborShapes() [2/2]

void Assembly::copyNeighborShapes

(

unsigned int

var

)

Definition at line 3149 of file Assembly.C.

{
  auto & v = _sys.getVariable(_tid, var);
  if (v.fieldType() == Moose::VarFieldType::VAR_FIELD_STANDARD)
  {
    auto & v = _sys.getActualFieldVariable<Real>(_tid, var);
    copyNeighborShapes(v);
  }
  else if (v.fieldType() == Moose::VarFieldType::VAR_FIELD_ARRAY)
  {
    auto & v = _sys.getActualFieldVariable<RealEigenVector>(_tid, var);
    copyNeighborShapes(v);
  }
  else if (v.fieldType() == Moose::VarFieldType::VAR_FIELD_VECTOR)
  {
    auto & v = _sys.getActualFieldVariable<RealVectorValue>(_tid, var);
    copyNeighborShapes(v);
  }
  else
    mooseError("Unsupported variable field type!");
}

copyShapes() [1/2]

template<typename T >

void Assembly::copyShapes

(

MooseVariableField< T > &

v

)

Definition at line 3055 of file Assembly.C.

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

Referenced by copyShapes().

copyShapes() [2/2]

void Assembly::copyShapes

(

unsigned int

var

)

Definition at line 3064 of file Assembly.C.

{
  auto & v = _sys.getVariable(_tid, var);
  if (v.fieldType() == Moose::VarFieldType::VAR_FIELD_STANDARD)
  {
    auto & v = _sys.getActualFieldVariable<Real>(_tid, var);
    copyShapes(v);
  }
  else if (v.fieldType() == Moose::VarFieldType::VAR_FIELD_ARRAY)
  {
    auto & v = _sys.getActualFieldVariable<RealEigenVector>(_tid, var);
    copyShapes(v);
  }
  else if (v.fieldType() == Moose::VarFieldType::VAR_FIELD_VECTOR)
  {
    auto & v = _sys.getActualFieldVariable<RealVectorValue>(_tid, var);
    copyShapes(v);
    if (v.computingCurl())
      curlPhi(v).shallowCopy(v.curlPhi());
    if (v.computingDiv())
      divPhi(v).shallowCopy(v.divPhi());
  }
  else
    mooseError("Unsupported variable field type!");
}

couplingEntries() [1/2]

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

inline

Definition at line 1286 of file Assembly.h.

  {
    return _cm_ff_entry;
  }

Referenced by MortarConstraint::computeJacobian().

couplingEntries() [2/2]

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

inline

Definition at line 1291 of file Assembly.h.

  {
    return _cm_ff_entry;
  }

createQRules()

void Assembly::createQRules	(	QuadratureType	type,
		Order	order,
		Order	volume_order,
		Order	face_order,
		SubdomainID	block,
		bool	allow_negative_qweights = true
	)

Creates block-specific volume, face and arbitrary qrules based on the orders and the flag of whether or not to allow negative qweights passed in.

Any quadrature rules specified using this function override those created via in the non-block-specific/global createQRules function. order is used for arbitrary volume quadrature rules, while volume_order and face_order are for elem and face quadrature respectively.

Definition at line 654 of file Assembly.C.

{
  auto & qvec = _qrules[block];
  unsigned int ndims = _mesh_dimension + 1; // must account for 0-dimensional quadrature.
  if (qvec.size() != ndims)
    qvec.resize(ndims);
 
  for (unsigned int i = 0; i < qvec.size(); i++)
  {
    int dim = i;
    auto & q = qvec[dim];
    q.vol = QBase::build(type, dim, volume_order);
    q.vol->allow_rules_with_negative_weights = allow_negative_qweights;
    q.face = QBase::build(type, dim - 1, face_order);
    q.face->allow_rules_with_negative_weights = allow_negative_qweights;
    q.fv_face = QBase::build(libMesh::QMONOMIAL, dim - 1, CONSTANT);
    q.fv_face->allow_rules_with_negative_weights = allow_negative_qweights;
    q.neighbor = std::make_unique<ArbitraryQuadrature>(dim - 1, face_order);
    q.neighbor->allow_rules_with_negative_weights = allow_negative_qweights;
    q.arbitrary_vol = std::make_unique<ArbitraryQuadrature>(dim, order);
    q.arbitrary_vol->allow_rules_with_negative_weights = allow_negative_qweights;
    q.arbitrary_face = std::make_unique<ArbitraryQuadrature>(dim - 1, face_order);
    q.arbitrary_face->allow_rules_with_negative_weights = allow_negative_qweights;
  }
 
  delete _qrule_msm;
  _custom_mortar_qrule = false;
  _qrule_msm = QBase::build(type, _mesh_dimension - 1, face_order).release();
  _qrule_msm->allow_rules_with_negative_weights = allow_negative_qweights;
  _fe_msm->attach_quadrature_rule(_qrule_msm);
}

Referenced by bumpAllQRuleOrder(), and bumpVolumeQRuleOrder().

curlPhi() [1/2]

VectorVariablePhiCurl & Assembly::curlPhi ( const MooseVariableField< RealVectorValue > &  )

inline

Definition at line 1498 of file Assembly.h.

  {
    return _vector_curl_phi;
  }

curlPhi() [2/2]

const VectorVariablePhiCurl & Assembly::curlPhi ( const MooseVariableField< RealVectorValue > &  ) const

inline

Definition at line 1377 of file Assembly.h.

  {
    return _vector_curl_phi;
  }

Referenced by copyShapes().

curlPhiFace() [1/2]

VectorVariablePhiCurl & Assembly::curlPhiFace ( const MooseVariableField< RealVectorValue > &  )

inline

Definition at line 1519 of file Assembly.h.

  {
    return _vector_curl_phi_face;
  }

curlPhiFace() [2/2]

const VectorVariablePhiCurl & Assembly::curlPhiFace ( const MooseVariableField< RealVectorValue > &  ) const

inline

Definition at line 1398 of file Assembly.h.

  {
    return _vector_curl_phi_face;
  }

curlPhiFaceNeighbor() [1/2]

VectorVariablePhiCurl & Assembly::curlPhiFaceNeighbor ( const MooseVariableField< RealVectorValue > &  )

inline

Definition at line 1560 of file Assembly.h.

  {
    return _vector_curl_phi_face_neighbor;
  }

curlPhiFaceNeighbor() [2/2]

const VectorVariablePhiCurl & Assembly::curlPhiFaceNeighbor ( const MooseVariableField< RealVectorValue > &  ) const

inline

Definition at line 1446 of file Assembly.h.

  {
    return _vector_curl_phi_face_neighbor;
  }

curlPhiNeighbor() [1/2]

VectorVariablePhiCurl & Assembly::curlPhiNeighbor ( const MooseVariableField< RealVectorValue > &  )

inline

Definition at line 1540 of file Assembly.h.

  {
    return _vector_curl_phi_neighbor;
  }

curlPhiNeighbor() [2/2]

const VectorVariablePhiCurl & Assembly::curlPhiNeighbor ( const MooseVariableField< RealVectorValue > &  ) const

inline

Definition at line 1421 of file Assembly.h.

  {
    return _vector_curl_phi_neighbor;
  }

currentBoundaryID()

const BoundaryID & Assembly::currentBoundaryID ( ) const

inline

Return the current boundary ID.

Definition at line 421 of file Assembly.h.

{ return _current_boundary_id; }

currentNeighborSubdomainID()

const SubdomainID & Assembly::currentNeighborSubdomainID ( ) const

inline

Return the current subdomain ID.

Definition at line 489 of file Assembly.h.

{ return _current_neighbor_subdomain_id; }

currentSubdomainID()

const SubdomainID & Assembly::currentSubdomainID ( ) const

inline

Return the current subdomain ID.

Definition at line 411 of file Assembly.h.

{ return _current_subdomain_id; }

divPhi() [1/2]

VectorVariablePhiDivergence & Assembly::divPhi ( const MooseVariableField< RealVectorValue > &  )

inline

Definition at line 1502 of file Assembly.h.

  {
    return _vector_div_phi;
  }

divPhi() [2/2]

const VectorVariablePhiDivergence & Assembly::divPhi ( const MooseVariableField< RealVectorValue > &  ) const

inline

Definition at line 1381 of file Assembly.h.

  {
    return _vector_div_phi;
  }

Referenced by copyShapes().

divPhiFace() [1/2]

VectorVariablePhiDivergence & Assembly::divPhiFace ( const MooseVariableField< RealVectorValue > &  )

inline

Definition at line 1523 of file Assembly.h.

  {
    return _vector_div_phi_face;
  }

divPhiFace() [2/2]

const VectorVariablePhiDivergence & Assembly::divPhiFace ( const MooseVariableField< RealVectorValue > &  ) const

inline

Definition at line 1402 of file Assembly.h.

  {
    return _vector_div_phi_face;
  }

divPhiFaceNeighbor() [1/2]

VectorVariablePhiDivergence & Assembly::divPhiFaceNeighbor ( const MooseVariableField< RealVectorValue > &  )

inline

Definition at line 1564 of file Assembly.h.

  {
    return _vector_div_phi_face_neighbor;
  }

divPhiFaceNeighbor() [2/2]

const VectorVariablePhiDivergence & Assembly::divPhiFaceNeighbor ( const MooseVariableField< RealVectorValue > &  ) const

inline

Definition at line 1451 of file Assembly.h.

  {
    return _vector_div_phi_face_neighbor;
  }

divPhiNeighbor() [1/2]

VectorVariablePhiDivergence & Assembly::divPhiNeighbor ( const MooseVariableField< RealVectorValue > &  )

inline

Definition at line 1544 of file Assembly.h.

  {
    return _vector_div_phi_neighbor;
  }

divPhiNeighbor() [2/2]

const VectorVariablePhiDivergence & Assembly::divPhiNeighbor ( const MooseVariableField< RealVectorValue > &  ) const

inline

Definition at line 1426 of file Assembly.h.

  {
    return _vector_div_phi_neighbor;
  }

elem()

const Elem *const & Assembly::elem ( ) const

inline

Return the current element.

Returns

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

Definition at line 406 of file Assembly.h.

{ return _current_elem; }

Referenced by computeADFace(), computeFaceMap(), computeGradPhiAD(), computeSinglePointMapAD(), elementVolume(), Moose::globalDofIndexToDerivative(), modifyFaceWeightsDueToXFEM(), modifyWeightsDueToXFEM(), MooseLinearVariableFV< OutputType >::MooseLinearVariableFV(), MooseVariableFE< OutputType >::MooseVariableFE(), MooseVariableFV< RealEigenVector >::MooseVariableFV(), qruleArbitraryFace(), qruleFace(), qruleFaceHelper(), reinit(), reinit(), reinit(), reinit(), reinitAtPhysical(), reinitDual(), reinitElemAndNeighbor(), reinitElemFaceRef(), reinitFE(), reinitFEFace(), reinitLowerDElem(), reinitMortarElem(), reinitNeighborLowerDElem(), setFaceQRule(), and setVolumeQRule().

elementVolume()

Real Assembly::elementVolume

(

const Elem *

elem

)

const

On-demand computation of volume element accounting for RZ/RSpherical.

Definition at line 3809 of file Assembly.C.

{
  FEType fe_type(elem->default_order(), LAGRANGE);
  std::unique_ptr<FEBase> fe(FEBase::build(elem->dim(), fe_type));
 
  // references to the quadrature points and weights
  const std::vector<Real> & JxW = fe->get_JxW();
  const std::vector<Point> & q_points = fe->get_xyz();
 
  // The default quadrature rule should integrate the mass matrix,
  // thus it should be plenty to compute the volume
  QGauss qrule(elem->dim(), fe_type.default_quadrature_order());
  fe->attach_quadrature_rule(&qrule);
  fe->reinit(elem);
 
  // perform a sanity check to ensure that size of quad rule and size of q_points is
  // identical
  mooseAssert(qrule.n_points() == q_points.size(),
              "The number of points in the quadrature rule doesn't match the number of passed-in "
              "points in Assembly::setCoordinateTransformation");
 
  // compute the coordinate transformation
  Real vol = 0;
  for (unsigned int qp = 0; qp < qrule.n_points(); ++qp)
  {
    Real coord;
    coordTransformFactor(_subproblem, elem->subdomain_id(), q_points[qp], coord);
    vol += JxW[qp] * coord;
  }
  return vol;
}

Referenced by MoveNodesByParsedExpressionModifier::prepare(), reinitLowerDElem(), reinitNeighborLowerDElem(), and MoveNodesByParsedExpressionModifier::writeOutputs().

elemVolume()

const Real & Assembly::elemVolume ( ) const

inline

Returns the reference to the current element volume.

Returns

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

Definition at line 432 of file Assembly.h.

{ return _current_elem_volume; }

Referenced by FVElementalKernel::computeJacobian(), FVScalarLagrangeMultiplierConstraint::computeOffDiagJacobian(), FVElementalKernel::computeResidual(), FVScalarLagrangeMultiplierConstraint::computeResidual(), FVElementalKernel::computeResidualAndJacobian(), and FVScalarLagrangeMultiplierConstraint::computeResidualAndJacobian().

extraElemID()

const dof_id_type & Assembly::extraElemID ( unsigned int  id ) const

inline

Returns an integer ID of the current element given the index associated with the integer.

Definition at line 370 of file Assembly.h.

  {
    mooseAssert(id < _extra_elem_ids.size(), "An invalid extra element integer id");
    return _extra_elem_ids[id];
  }

extraElemIDNeighbor()

const dof_id_type & Assembly::extraElemIDNeighbor ( unsigned int  id ) const

inline

Returns an integer ID of the current element given the index associated with the integer.

Definition at line 379 of file Assembly.h.

  {
    mooseAssert(id < _neighbor_extra_elem_ids.size(), "An invalid extra element integer id");
    return _neighbor_extra_elem_ids[id];
  }

feADGradPhi() [1/2]

template<typename OutputType >

const ADTemplateVariablePhiGradient< OutputType > & Assembly::feADGradPhi ( FEType  type ) const

inline

Definition at line 1625 of file Assembly.h.

  {
    return _ad_grad_phi_data[type];
  }

feADGradPhi() [2/2]

template<>

const ADTemplateVariablePhiGradient< RealVectorValue > & Assembly::feADGradPhi ( FEType  type ) const

inline

Definition at line 2929 of file Assembly.h.

{
  return _ad_vector_grad_phi_data[type];
}

feADGradPhiFace() [1/2]

template<typename OutputType >

const ADTemplateVariablePhiGradient< OutputType > & Assembly::feADGradPhiFace ( FEType  type ) const

inline

Definition at line 1666 of file Assembly.h.

  {
    return _ad_grad_phi_data_face[type];
  }

feADGradPhiFace() [2/2]

template<>

const ADTemplateVariablePhiGradient< RealVectorValue > & Assembly::feADGradPhiFace ( FEType  type ) const

inline

Definition at line 2936 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 ) const

inline

Definition at line 1732 of file Assembly.h.

  {
    _need_curl.insert(type);
    buildFE(type);
    return _fe_shape_data[type]->_curl_phi;
  }

feCurlPhi() [2/3]

template<>

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

(

FEType

type

)

const

feCurlPhi() [3/3]

template<>

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

(

FEType

type

)

const

Definition at line 4758 of file Assembly.C.

{
  _need_curl.insert(type);
  buildVectorFE(type);
  return _vector_fe_shape_data[type]->_curl_phi;
}

feCurlPhiFace() [1/3]

template<typename OutputType >

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

inline

Definition at line 1740 of file Assembly.h.

  {
    _need_curl.insert(type);
    buildFaceFE(type);
    return _fe_shape_data_face[type]->_curl_phi;
  }

feCurlPhiFace() [2/3]

template<>

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

(

FEType

type

)

const

feCurlPhiFace() [3/3]

template<>

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

(

FEType

type

)

const

Definition at line 4767 of file Assembly.C.

{
  _need_curl.insert(type);
  buildVectorFaceFE(type);
 
  // If we're building for a face we probably need to build for a
  // neighbor while _need_curl is set;
  // onInterface/reinitNeighbor/etc don't distinguish
  buildVectorFaceNeighborFE(type);
 
  return _vector_fe_shape_data_face[type]->_curl_phi;
}

feCurlPhiFaceNeighbor() [1/3]

template<typename OutputType >

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

inline

Definition at line 1756 of file Assembly.h.

  {
    _need_curl.insert(type);
    buildFaceNeighborFE(type);
    return _fe_shape_data_face_neighbor[type]->_curl_phi;
  }

feCurlPhiFaceNeighbor() [2/3]

template<>

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

(

FEType

type

)

const

feCurlPhiFaceNeighbor() [3/3]

template<>

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

(

FEType

type

)

const

Definition at line 4791 of file Assembly.C.

{
  _need_curl.insert(type);
  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 ) const

inline

Definition at line 1748 of file Assembly.h.

  {
    _need_curl.insert(type);
    buildNeighborFE(type);
    return _fe_shape_data_neighbor[type]->_curl_phi;
  }

feCurlPhiNeighbor() [2/3]

template<>

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

(

FEType

type

)

const

feCurlPhiNeighbor() [3/3]

template<>

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

(

FEType

type

)

const

Definition at line 4782 of file Assembly.C.

{
  _need_curl.insert(type);
  buildVectorNeighborFE(type);
  return _vector_fe_shape_data_neighbor[type]->_curl_phi;
}

feDivPhi() [1/3]

template<typename OutputType >

const OutputTools< OutputType >::VariablePhiDivergence & Assembly::feDivPhi ( FEType  type ) const

inline

Definition at line 1764 of file Assembly.h.

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

feDivPhi() [2/3]

template<>

const OutputTools< VectorValue< Real > >::VariablePhiDivergence & Assembly::feDivPhi

(

FEType

type

)

const

feDivPhi() [3/3]

template<>

const OutputTools< VectorValue< Real > >::VariablePhiDivergence & Assembly::feDivPhi

(

FEType

type

)

const

Definition at line 4801 of file Assembly.C.

{
  _need_div.insert(type);
  buildVectorFE(type);
  return _vector_fe_shape_data[type]->_div_phi;
}

feDivPhiFace() [1/3]

template<typename OutputType >

const OutputTools< OutputType >::VariablePhiDivergence & Assembly::feDivPhiFace ( FEType  type ) const

inline

Definition at line 1771 of file Assembly.h.

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

feDivPhiFace() [2/3]

template<>

const OutputTools< VectorValue< Real > >::VariablePhiDivergence & Assembly::feDivPhiFace

(

FEType

type

)

const

feDivPhiFace() [3/3]

template<>

const OutputTools< VectorValue< Real > >::VariablePhiDivergence & Assembly::feDivPhiFace

(

FEType

type

)

const

Definition at line 4810 of file Assembly.C.

{
  _need_face_div.insert(type);
  buildVectorFaceFE(type);
 
  // If we're building for a face we probably need to build for a
  // neighbor while _need_face_div is set;
  // onInterface/reinitNeighbor/etc don't distinguish
  buildVectorFaceNeighborFE(type);
 
  return _vector_fe_shape_data_face[type]->_div_phi;
}

feDivPhiFaceNeighbor() [1/3]

template<typename OutputType >

const OutputTools< OutputType >::VariablePhiDivergence & Assembly::feDivPhiFaceNeighbor ( FEType  type ) const

inline

Definition at line 1787 of file Assembly.h.

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

feDivPhiFaceNeighbor() [2/3]

template<>

const OutputTools< VectorValue< Real > >::VariablePhiDivergence & Assembly::feDivPhiFaceNeighbor

(

FEType

type

)

const

feDivPhiFaceNeighbor() [3/3]

template<>

const OutputTools< VectorValue< Real > >::VariablePhiDivergence & Assembly::feDivPhiFaceNeighbor

(

FEType

type

)

const

Definition at line 4834 of file Assembly.C.

{
  _need_face_neighbor_div.insert(type);
  buildVectorFaceNeighborFE(type);
  return _vector_fe_shape_data_face_neighbor[type]->_div_phi;
}

feDivPhiNeighbor() [1/3]

template<typename OutputType >

const OutputTools< OutputType >::VariablePhiDivergence & Assembly::feDivPhiNeighbor ( FEType  type ) const

inline

Definition at line 1779 of file Assembly.h.

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

feDivPhiNeighbor() [2/3]

template<>

const OutputTools< VectorValue< Real > >::VariablePhiDivergence & Assembly::feDivPhiNeighbor

(

FEType

type

)

const

feDivPhiNeighbor() [3/3]

template<>

const OutputTools< VectorValue< Real > >::VariablePhiDivergence & Assembly::feDivPhiNeighbor

(

FEType

type

)

const

Definition at line 4825 of file Assembly.C.

{
  _need_neighbor_div.insert(type);
  buildVectorNeighborFE(type);
  return _vector_fe_shape_data_neighbor[type]->_div_phi;
}

feDualPhiLower() [1/3]

template<typename OutputType >

const OutputTools< OutputType >::VariablePhiValue & Assembly::feDualPhiLower

(

FEType

type

)

const

Definition at line 2906 of file Assembly.h.

{
  buildLowerDDualFE(type);
  return _fe_shape_data_dual_lower[type]->_phi;
}

feDualPhiLower() [2/3]

template<>

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

(

FEType

type

)

const

feDualPhiLower() [3/3]

template<>

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

(

FEType

type

)

const

Definition at line 4653 of file Assembly.C.

{
  buildVectorDualLowerDFE(type);
  return _vector_fe_shape_data_dual_lower[type]->_phi;
}

feGradDualPhiLower() [1/3]

template<typename OutputType >

const OutputTools< OutputType >::VariablePhiGradient & Assembly::feGradDualPhiLower

(

FEType

type

)

const

Definition at line 2922 of file Assembly.h.

{
  buildLowerDDualFE(type);
  return _fe_shape_data_dual_lower[type]->_grad_phi;
}

feGradDualPhiLower() [2/3]

template<>

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

(

FEType

type

)

const

feGradDualPhiLower() [3/3]

template<>

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

(

FEType

type

)

const

Definition at line 4669 of file Assembly.C.

{
  buildVectorDualLowerDFE(type);
  return _vector_fe_shape_data_dual_lower[type]->_grad_phi;
}

feGradPhi() [1/3]

template<typename OutputType >

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

inline

Definition at line 1618 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

)

const

feGradPhi() [3/3]

template<>

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

(

FEType

type

)

const

Definition at line 4628 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 ) const

inline

Definition at line 1659 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

)

const

feGradPhiFace() [3/3]

template<>

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

(

FEType

type

)

const

Definition at line 4685 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 ) const

inline

Definition at line 1716 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

)

const

feGradPhiFaceNeighbor() [3/3]

template<>

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

(

FEType

type

)

const

Definition at line 4741 of file Assembly.C.

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

feGradPhiLower() [1/3]

template<typename OutputType >

const OutputTools< OutputType >::VariablePhiGradient & Assembly::feGradPhiLower

(

FEType

type

)

const

Definition at line 2914 of file Assembly.h.

{
  buildLowerDFE(type);
  return _fe_shape_data_lower[type]->_grad_phi;
}

feGradPhiLower() [2/3]

template<>

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

(

FEType

type

)

const

feGradPhiLower() [3/3]

template<>

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

(

FEType

type

)

const

Definition at line 4661 of file Assembly.C.

{
  buildVectorLowerDFE(type);
  return _vector_fe_shape_data_lower[type]->_grad_phi;
}

feGradPhiNeighbor() [1/3]

template<typename OutputType >

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

inline

Definition at line 1693 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

)

const

feGradPhiNeighbor() [3/3]

template<>

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

(

FEType

type

)

const

Definition at line 4716 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 ) const

inline

Definition at line 1611 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

)

const

fePhi() [3/3]

template<>

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

(

FEType

type

)

const

Definition at line 4620 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 ) const

inline

Definition at line 1652 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

)

const

fePhiFace() [3/3]

template<>

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

(

FEType

type

)

const

Definition at line 4677 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 ) const

inline

Definition at line 1708 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

)

const

fePhiFaceNeighbor() [3/3]

template<>

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

(

FEType

type

)

const

Definition at line 4733 of file Assembly.C.

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

fePhiLower() [1/3]

template<typename OutputType >

const OutputTools< OutputType >::VariablePhiValue & Assembly::fePhiLower

(

FEType

type

)

const

Definition at line 2898 of file Assembly.h.

{
  buildLowerDFE(type);
  return _fe_shape_data_lower[type]->_phi;
}

fePhiLower() [2/3]

template<>

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

(

FEType

type

)

const

fePhiLower() [3/3]

template<>

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

(

FEType

type

)

const

Definition at line 4645 of file Assembly.C.

{
  buildVectorLowerDFE(type);
  return _vector_fe_shape_data_lower[type]->_phi;
}

fePhiNeighbor() [1/3]

template<typename OutputType >

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

inline

Definition at line 1686 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

)

const

fePhiNeighbor() [3/3]

template<>

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

(

FEType

type

)

const

Definition at line 4708 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 ) const

inline

Definition at line 1631 of file Assembly.h.

  {
    _need_second_derivative.insert(type);
    buildFE(type);
    return _fe_shape_data[type]->_second_phi;
  }

feSecondPhi() [2/3]

template<>

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

(

FEType

type

)

const

feSecondPhi() [3/3]

template<>

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

(

FEType

type

)

const

Definition at line 4636 of file Assembly.C.

{
  _need_second_derivative.insert(type);
  buildVectorFE(type);
  return _vector_fe_shape_data[type]->_second_phi;
}

feSecondPhiFace() [1/3]

template<typename OutputType >

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

inline

Definition at line 1678 of file Assembly.h.

  {
    _need_second_derivative.insert(type);
    buildFaceFE(type);
    return _fe_shape_data_face[type]->_second_phi;
  }

feSecondPhiFace() [2/3]

template<>

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

(

FEType

type

)

const

feSecondPhiFace() [3/3]

template<>

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

(

FEType

type

)

const

Definition at line 4693 of file Assembly.C.

{
  _need_second_derivative.insert(type);
  buildVectorFaceFE(type);
 
  // If we're building for a face we probably need to build for a
  // neighbor while _need_second_derivative is set;
  // onInterface/reinitNeighbor/etc don't distinguish
  buildVectorFaceNeighborFE(type);
 
  return _vector_fe_shape_data_face[type]->_second_phi;
}

feSecondPhiFaceNeighbor() [1/3]

template<typename OutputType >

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

inline

Definition at line 1724 of file Assembly.h.

  {
    _need_second_derivative_neighbor.insert(type);
    buildFaceNeighborFE(type);
    return _fe_shape_data_face_neighbor[type]->_second_phi;
  }

feSecondPhiFaceNeighbor() [2/3]

template<>

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

(

FEType

type

)

const

feSecondPhiFaceNeighbor() [3/3]

template<>

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

(

FEType

type

)

const

Definition at line 4749 of file Assembly.C.

{
  _need_second_derivative_neighbor.insert(type);
  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 ) const

inline

Definition at line 1700 of file Assembly.h.

  {
    _need_second_derivative_neighbor.insert(type);
    buildNeighborFE(type);
    return _fe_shape_data_neighbor[type]->_second_phi;
  }

feSecondPhiNeighbor() [2/3]

template<>

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

(

FEType

type

)

const

feSecondPhiNeighbor() [3/3]

template<>

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

(

FEType

type

)

const

Definition at line 4724 of file Assembly.C.

{
  _need_second_derivative_neighbor.insert(type);
  buildVectorNeighborFE(type);
  return _vector_fe_shape_data_neighbor[type]->_second_phi;
}

fieldScalarCouplingEntries()

const std::vector< std::pair< MooseVariableFieldBase *, MooseVariableScalar * > > & Assembly::fieldScalarCouplingEntries ( ) const

inline

Definition at line 1301 of file Assembly.h.

  {
    return _cm_fs_entry;
  }

genericQPoints() [1/3]

template<bool is_ad>

const MooseArray< Moose::GenericType< Point, is_ad > > & Assembly::genericQPoints

(

)

const

genericQPoints() [2/3]

template<>

const MooseArray< Moose::GenericType< Point, false > > & Assembly::genericQPoints

(

)

const

Definition at line 4976 of file Assembly.C.

{
  return qPoints();
}

genericQPoints() [3/3]

template<>

const MooseArray< Moose::GenericType< Point, true > > & Assembly::genericQPoints

(

)

const

Definition at line 4983 of file Assembly.C.

{
  return adQPoints();
}

getFE()

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

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 124 of file Assembly.h.

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

Referenced by PointVariableSamplerBase::initialize().

getFEFace()

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

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 148 of file Assembly.h.

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

getFEFaceNeighbor()

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

inline

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

Parameters

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

Returns

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

Definition at line 160 of file Assembly.h.

  {
    buildFaceNeighborFE(type);
    return constify_ref(_fe_face_neighbor[dim][type]);
  }

getFENeighbor()

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

inline

Get a reference to a pointer that will contain the current 'neighbor' 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 136 of file Assembly.h.

  {
    buildNeighborFE(type);
    return constify_ref(_fe_neighbor[dim][type]);
  }

getJacobianDiagonal()

DenseVector< Real > Assembly::getJacobianDiagonal ( const DenseMatrix< Number > &  ke )

inline

Definition at line 1890 of file Assembly.h.

  {
    unsigned int rows = ke.m();
    unsigned int cols = ke.n();
    DenseVector<Real> diag(rows);
    for (unsigned int i = 0; i < rows; i++)
      // % operation is needed to account for cases of no component coupling of array variables
      diag(i) = ke(i, i % cols);
    return diag;
  }

Referenced by ArrayDGKernel::computeElemNeighJacobian(), ArrayIntegratedBC::computeJacobian(), ArrayKernel::computeJacobian(), EigenKernel::computeJacobian(), Kernel::computeJacobian(), ArrayDGKernel::computeOffDiagElemNeighJacobian(), ArrayIntegratedBC::computeOffDiagJacobian(), and ArrayKernel::computeOffDiagJacobian().

getVectorFE()

const FEVectorBase *const & Assembly::getVectorFE ( FEType  type, unsigned int  dim  ) const

inline

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

Parameters

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

Returns

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

Definition at line 172 of file Assembly.h.

  {
    buildVectorFE(type);
    return constify_ref(_vector_fe[dim][type]);
  }

getVectorFEFace()

const FEVectorBase *const & Assembly::getVectorFEFace ( FEType  type, unsigned int  dim  ) const

inline

GetVector 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 196 of file Assembly.h.

  {
    buildVectorFaceFE(type);
    return constify_ref(_vector_fe_face[dim][type]);
  }

getVectorFEFaceNeighbor()

const FEVectorBase *const & Assembly::getVectorFEFaceNeighbor ( FEType  type, unsigned int  dim  ) const

inline

GetVector a reference to a pointer that will contain the current "neighbor" FE.

Parameters

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

Returns

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

Definition at line 208 of file Assembly.h.

  {
    buildVectorFaceNeighborFE(type);
    return constify_ref(_vector_fe_face_neighbor[dim][type]);
  }

getVectorFENeighbor()

const FEVectorBase *const & Assembly::getVectorFENeighbor ( FEType  type, unsigned int  dim  ) const

inline

GetVector a reference to a pointer that will contain the current 'neighbor' 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 184 of file Assembly.h.

  {
    buildVectorNeighborFE(type);
    return constify_ref(_vector_fe_neighbor[dim][type]);
  }

gradPhi() [1/6]

const VariablePhiGradient & Assembly::gradPhi ( ) const

inline

Definition at line 1319 of file Assembly.h.

{ return _grad_phi; }

Referenced by copyShapes().

gradPhi() [2/6]

VariablePhiGradient & Assembly::gradPhi ( const MooseVariableField< Real > &  )

inline

Definition at line 1458 of file Assembly.h.

{ return _grad_phi; }

gradPhi() [3/6]

const VariablePhiGradient & Assembly::gradPhi ( const MooseVariableField< Real > &  ) const

inline

Definition at line 1320 of file Assembly.h.

{ return _grad_phi; }

gradPhi() [4/6]

VariablePhiGradient & Assembly::gradPhi ( const MooseVariableField< RealEigenVector > &  )

inline

Definition at line 1571 of file Assembly.h.

{ return _grad_phi; }

gradPhi() [5/6]

VectorVariablePhiGradient & Assembly::gradPhi ( const MooseVariableField< RealVectorValue > &  )

inline

Definition at line 1490 of file Assembly.h.

  {
    return _vector_grad_phi;
  }

gradPhi() [6/6]

const VectorVariablePhiGradient & Assembly::gradPhi ( const MooseVariableField< RealVectorValue > &  ) const

inline

Definition at line 1369 of file Assembly.h.

  {
    return _vector_grad_phi;
  }

gradPhiFace() [1/6]

const VariablePhiGradient & Assembly::gradPhiFace ( ) const

inline

Definition at line 1329 of file Assembly.h.

{ return _grad_phi_face; }

Referenced by copyFaceShapes().

gradPhiFace() [2/6]

VariablePhiGradient & Assembly::gradPhiFace ( const MooseVariableField< Real > &  )

inline

Definition at line 1462 of file Assembly.h.

{ return _grad_phi_face; }

gradPhiFace() [3/6]

const VariablePhiGradient & Assembly::gradPhiFace ( const MooseVariableField< Real > &  ) const

inline

Definition at line 1330 of file Assembly.h.

  {
    return _grad_phi_face;
  }

gradPhiFace() [4/6]

VariablePhiGradient & Assembly::gradPhiFace ( const MooseVariableField< RealEigenVector > &  )

inline

Definition at line 1575 of file Assembly.h.

  {
    return _grad_phi_face;
  }

gradPhiFace() [5/6]

VectorVariablePhiGradient & Assembly::gradPhiFace ( const MooseVariableField< RealVectorValue > &  )

inline

Definition at line 1511 of file Assembly.h.

  {
    return _vector_grad_phi_face;
  }

gradPhiFace() [6/6]

const VectorVariablePhiGradient & Assembly::gradPhiFace ( const MooseVariableField< RealVectorValue > &  ) const

inline

Definition at line 1390 of file Assembly.h.

  {
    return _vector_grad_phi_face;
  }

gradPhiFaceNeighbor() [1/5]

VariablePhiGradient & Assembly::gradPhiFaceNeighbor ( const MooseVariableField< Real > &  )

inline

Definition at line 1479 of file Assembly.h.

  {
    return _grad_phi_face_neighbor;
  }

gradPhiFaceNeighbor() [2/5]

const VariablePhiGradient & Assembly::gradPhiFaceNeighbor ( const MooseVariableField< Real > &  ) const

inline

Definition at line 1356 of file Assembly.h.

  {
    return _grad_phi_face_neighbor;
  }

Referenced by copyNeighborShapes().

gradPhiFaceNeighbor() [3/5]

VariablePhiGradient & Assembly::gradPhiFaceNeighbor ( const MooseVariableField< RealEigenVector > &  )

inline

Definition at line 1601 of file Assembly.h.

  {
    return _grad_phi_face_neighbor;
  }

gradPhiFaceNeighbor() [4/5]

VectorVariablePhiGradient & Assembly::gradPhiFaceNeighbor ( const MooseVariableField< RealVectorValue > &  )

inline

Definition at line 1552 of file Assembly.h.

  {
    return _vector_grad_phi_face_neighbor;
  }

gradPhiFaceNeighbor() [5/5]

const VectorVariablePhiGradient & Assembly::gradPhiFaceNeighbor ( const MooseVariableField< RealVectorValue > &  ) const

inline

Definition at line 1436 of file Assembly.h.

  {
    return _vector_grad_phi_face_neighbor;
  }

gradPhiNeighbor() [1/5]

VariablePhiGradient & Assembly::gradPhiNeighbor ( const MooseVariableField< Real > &  )

inline

Definition at line 1466 of file Assembly.h.

  {
    return _grad_phi_neighbor;
  }

gradPhiNeighbor() [2/5]

const VariablePhiGradient & Assembly::gradPhiNeighbor ( const MooseVariableField< Real > &  ) const

inline

Definition at line 1343 of file Assembly.h.

  {
    return _grad_phi_neighbor;
  }

Referenced by copyNeighborShapes().

gradPhiNeighbor() [3/5]

VariablePhiGradient & Assembly::gradPhiNeighbor ( const MooseVariableField< RealEigenVector > &  )

inline

Definition at line 1588 of file Assembly.h.

  {
    return _grad_phi_neighbor;
  }

gradPhiNeighbor() [4/5]

VectorVariablePhiGradient & Assembly::gradPhiNeighbor ( const MooseVariableField< RealVectorValue > &  )

inline

Definition at line 1532 of file Assembly.h.

  {
    return _vector_grad_phi_neighbor;
  }

gradPhiNeighbor() [5/5]

const VectorVariablePhiGradient & Assembly::gradPhiNeighbor ( const MooseVariableField< RealVectorValue > &  ) const

inline

Definition at line 1412 of file Assembly.h.

  {
    return _vector_grad_phi_neighbor;
  }

helpersRequestData()

void Assembly::helpersRequestData ( )

private

request phi, dphi, xyz, JxW, etc.

data through the FE helper functions

Definition at line 4854 of file Assembly.C.

{
  for (unsigned int dim = 0; dim <= _mesh_dimension; dim++)
  {
    _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]->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]->get_xyz();
    _holder_fe_face_neighbor_helper[dim]->get_JxW();
    _holder_fe_face_neighbor_helper[dim]->get_normals();
 
    _holder_fe_neighbor_helper[dim]->get_xyz();
    _holder_fe_neighbor_helper[dim]->get_JxW();
  }
 
  for (unsigned int dim = 0; dim < _mesh_dimension; dim++)
  {
    // We need these computations in order to compute correct lower-d element volumes in
    // curvilinear coordinates
    _holder_fe_lower_helper[dim]->get_xyz();
    _holder_fe_lower_helper[dim]->get_JxW();
  }
}

Referenced by Assembly(), and preparePRefinement().

init()

void Assembly::init

(

const libMesh::CouplingMatrix *

cm

)

Initialize the Assembly object and set the CouplingMatrix for use throughout.

initNonlocalCoupling()

void Assembly::initNonlocalCoupling

(

)

Create pair of variables requiring nonlocal jacobian contributions.

Definition at line 2703 of file Assembly.C.

{
  _cm_nonlocal_entry.clear();
 
  auto & vars = _sys.getVariables(_tid);
 
  for (auto & ivar : vars)
  {
    auto i = ivar->number();
    auto ivar_start = _cm_nonlocal_entry.size();
    for (unsigned int k = 0; k < ivar->count(); ++k)
    {
      unsigned int iv = i + k;
      for (const auto & j : libMesh::ConstCouplingRow(iv, _nonlocal_cm))
        if (!_sys.isScalarVariable(j))
        {
          auto & jvar = _sys.getVariable(_tid, j);
          auto pair = std::make_pair(ivar, &jvar);
          auto c = ivar_start;
          // check if the pair has been pushed or not
          bool has_pair = false;
          for (; c < _cm_nonlocal_entry.size(); ++c)
            if (_cm_nonlocal_entry[c] == pair)
            {
              has_pair = true;
              break;
            }
          if (!has_pair)
            _cm_nonlocal_entry.push_back(pair);
        }
    }
  }
}

jacobianBlock()

DenseMatrix< Number > & Assembly::jacobianBlock ( unsigned int  ivar, unsigned int  jvar, LocalDataKey  , TagID  tag  )

inline

Get local Jacobian block for a pair of variables and a tag.

Only blessed framework classes may call this API by creating the requisiste LocalDataKey class

Definition at line 1134 of file Assembly.h.

  {
    jacobianBlockUsed(tag, ivar, jvar, true);
    return _sub_Kee[tag][ivar][_block_diagonal_matrix ? 0 : jvar];
  }

Referenced by TaggingInterface::accumulateTaggedLocalMatrix(), addJacobianCoupledVarPair(), cacheJacobianCoupledVarPair(), prepareBlock(), prepareJacobianBlock(), TaggingInterface::prepareMatrixTag(), TaggingInterface::prepareMatrixTag(), prepareOffDiagScalar(), prepareScalar(), and prepareVariable().

jacobianBlockLowerUsed() [1/2]

char Assembly::jacobianBlockLowerUsed ( TagID  tag, unsigned int  ivar, unsigned int  jvar  ) const

inlineprivate

Return a flag to indicate if a particular coupling lower Jacobian block between ivar and jvar is used.

Definition at line 2272 of file Assembly.h.

  {
    return _jacobian_block_lower_used[tag][ivar][_block_diagonal_matrix ? 0 : jvar];
  }

jacobianBlockLowerUsed() [2/2]

void Assembly::jacobianBlockLowerUsed ( TagID  tag, unsigned int  ivar, unsigned int  jvar, bool  used  )

inlineprivate

Sets whether or not lower Jacobian coupling between ivar and jvar is used to the value used.

Definition at line 2263 of file Assembly.h.

  {
    _jacobian_block_lower_used[tag][ivar][_block_diagonal_matrix ? 0 : jvar] = used;
  }

Referenced by addJacobianLowerD(), addJacobianNeighborLowerD(), cacheJacobianMortar(), jacobianBlockMortar(), and prepareLowerD().

jacobianBlockMortar()

DenseMatrix< Number > & Assembly::jacobianBlockMortar	(	Moose::ConstraintJacobianType	type,
		unsigned int	ivar,
		unsigned int	jvar,
		LocalDataKey	,
		TagID	tag
	)

Returns the jacobian block for the given mortar Jacobian type.

This jacobian block can involve degrees of freedom from the secondary side interior parent, the primary side interior parent, or the lower-dimensional element (located on the secondary side). Only blessed framework classes may call this API by creating the requisiste LocalDataKey class

Definition at line 3213 of file Assembly.C.

{
  jacobianBlockLowerUsed(tag, ivar, jvar, true);
  if (_block_diagonal_matrix)
  {
    switch (type)
    {
      default:
      case Moose::LowerLower:
        return _sub_Kll[tag][ivar][0];
      case Moose::LowerSecondary:
        return _sub_Kle[tag][ivar][0];
      case Moose::LowerPrimary:
        return _sub_Kln[tag][ivar][0];
      case Moose::SecondaryLower:
        return _sub_Kel[tag][ivar][0];
      case Moose::SecondarySecondary:
        return _sub_Kee[tag][ivar][0];
      case Moose::SecondaryPrimary:
        return _sub_Ken[tag][ivar][0];
      case Moose::PrimaryLower:
        return _sub_Knl[tag][ivar][0];
      case Moose::PrimarySecondary:
        return _sub_Kne[tag][ivar][0];
      case Moose::PrimaryPrimary:
        return _sub_Knn[tag][ivar][0];
    }
  }
  else
  {
    switch (type)
    {
      default:
      case Moose::LowerLower:
        return _sub_Kll[tag][ivar][jvar];
      case Moose::LowerSecondary:
        return _sub_Kle[tag][ivar][jvar];
      case Moose::LowerPrimary:
        return _sub_Kln[tag][ivar][jvar];
      case Moose::SecondaryLower:
        return _sub_Kel[tag][ivar][jvar];
      case Moose::SecondarySecondary:
        return _sub_Kee[tag][ivar][jvar];
      case Moose::SecondaryPrimary:
        return _sub_Ken[tag][ivar][jvar];
      case Moose::PrimaryLower:
        return _sub_Knl[tag][ivar][jvar];
      case Moose::PrimarySecondary:
        return _sub_Kne[tag][ivar][jvar];
      case Moose::PrimaryPrimary:
        return _sub_Knn[tag][ivar][jvar];
    }
  }
}

Referenced by addJacobianLowerD(), addJacobianNeighborLowerD(), cacheJacobianMortar(), prepareLowerD(), and TaggingInterface::prepareMatrixTagLower().

jacobianBlockNeighbor()

DenseMatrix< Number > & Assembly::jacobianBlockNeighbor	(	Moose::DGJacobianType	type,
		unsigned int	ivar,
		unsigned int	jvar,
		LocalDataKey	,
		TagID	tag
	)

Get local Jacobian block of a DG Jacobian type for a pair of variables and a tag.

Only blessed framework classes may call this API by creating the requisiste LocalDataKey class

Definition at line 3172 of file Assembly.C.

{
  if (type == Moose::ElementElement)
    jacobianBlockUsed(tag, ivar, jvar, true);
  else
    jacobianBlockNeighborUsed(tag, ivar, jvar, true);
 
  if (_block_diagonal_matrix)
  {
    switch (type)
    {
      default:
      case Moose::ElementElement:
        return _sub_Kee[tag][ivar][0];
      case Moose::ElementNeighbor:
        return _sub_Ken[tag][ivar][0];
      case Moose::NeighborElement:
        return _sub_Kne[tag][ivar][0];
      case Moose::NeighborNeighbor:
        return _sub_Knn[tag][ivar][0];
    }
  }
  else
  {
    switch (type)
    {
      default:
      case Moose::ElementElement:
        return _sub_Kee[tag][ivar][jvar];
      case Moose::ElementNeighbor:
        return _sub_Ken[tag][ivar][jvar];
      case Moose::NeighborElement:
        return _sub_Kne[tag][ivar][jvar];
      case Moose::NeighborNeighbor:
        return _sub_Knn[tag][ivar][jvar];
    }
  }
}

Referenced by TaggingInterface::accumulateTaggedLocalMatrix(), addJacobianNeighbor(), addJacobianNeighborLowerD(), cacheJacobianNeighbor(), TaggingInterface::prepareMatrixTagNeighbor(), TaggingInterface::prepareMatrixTagNeighbor(), and prepareNeighbor().

jacobianBlockNeighborUsed() [1/2]

char Assembly::jacobianBlockNeighborUsed ( TagID  tag, unsigned int  ivar, unsigned int  jvar  ) const

inlineprivate

Return a flag to indicate if a particular coupling neighbor Jacobian block between ivar and jvar is used.

Definition at line 2254 of file Assembly.h.

  {
    return _jacobian_block_neighbor_used[tag][ivar][_block_diagonal_matrix ? 0 : jvar];
  }

jacobianBlockNeighborUsed() [2/2]

void Assembly::jacobianBlockNeighborUsed ( TagID  tag, unsigned int  ivar, unsigned int  jvar, bool  used  )

inlineprivate

Sets whether or not neighbor Jacobian coupling between ivar and jvar is used to the value used.

Definition at line 2245 of file Assembly.h.

  {
    _jacobian_block_neighbor_used[tag][ivar][_block_diagonal_matrix ? 0 : jvar] = used;
  }

Referenced by addJacobianNeighbor(), addJacobianNeighborLowerD(), cacheJacobianNeighbor(), jacobianBlockNeighbor(), and prepareNeighbor().

jacobianBlockNonlocal()

DenseMatrix< Number > & Assembly::jacobianBlockNonlocal ( unsigned int  ivar, unsigned int  jvar, LocalDataKey  , TagID  tag  )

inline

Get local Jacobian block from non-local contribution for a pair of variables and a tag.

Only blessed framework classes may call this API by creating the requisiste LocalDataKey class

Definition at line 1145 of file Assembly.h.

  {
    jacobianBlockNonlocalUsed(tag, ivar, jvar, true);
    return _sub_Keg[tag][ivar][_block_diagonal_matrix ? 0 : jvar];
  }

Referenced by addJacobianBlockNonlocal(), addJacobianNonlocal(), cacheJacobianNonlocal(), prepareBlockNonlocal(), TaggingInterface::prepareMatrixTagNonlocal(), prepareNonlocal(), and prepareVariableNonlocal().

jacobianBlockNonlocalUsed() [1/2]

char Assembly::jacobianBlockNonlocalUsed ( TagID  tag, unsigned int  ivar, unsigned int  jvar  ) const

inlineprivate

Return a flag to indicate if a particular coupling nonlocal Jacobian block between ivar and jvar is used.

Definition at line 2290 of file Assembly.h.

  {
    return _jacobian_block_nonlocal_used[tag][ivar][_block_diagonal_matrix ? 0 : jvar];
  }

jacobianBlockNonlocalUsed() [2/2]

void Assembly::jacobianBlockNonlocalUsed ( TagID  tag, unsigned int  ivar, unsigned int  jvar, bool  used  )

inlineprivate

Sets whether or not nonlocal Jacobian coupling between ivar and jvar is used to the value used.

Definition at line 2281 of file Assembly.h.

  {
    _jacobian_block_nonlocal_used[tag][ivar][_block_diagonal_matrix ? 0 : jvar] = used;
  }

Referenced by addJacobianNonlocal(), cacheJacobianNonlocal(), jacobianBlockNonlocal(), prepareBlockNonlocal(), prepareNonlocal(), and prepareVariableNonlocal().

jacobianBlockUsed() [1/2]

char Assembly::jacobianBlockUsed ( TagID  tag, unsigned int  ivar, unsigned int  jvar  ) const

inlineprivate

Return a flag to indicate if a particular coupling Jacobian block between ivar and jvar is used.

Definition at line 2236 of file Assembly.h.

  {
    return _jacobian_block_used[tag][ivar][_block_diagonal_matrix ? 0 : jvar];
  }

jacobianBlockUsed() [2/2]

void Assembly::jacobianBlockUsed ( TagID  tag, unsigned int  ivar, unsigned int  jvar, bool  used  )

inlineprivate

Sets whether or not Jacobian coupling between ivar and jvar is used to the value used.

Definition at line 2227 of file Assembly.h.

  {
    _jacobian_block_used[tag][ivar][_block_diagonal_matrix ? 0 : jvar] = used;
  }

Referenced by addJacobianCoupledVarPair(), cacheJacobianCoupledVarPair(), jacobianBlock(), jacobianBlockNeighbor(), prepareBlock(), prepareJacobianBlock(), prepareOffDiagScalar(), prepareScalar(), and prepareVariable().

JxW()

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

inline

Returns the reference to the transformed jacobian weights.

Returns

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

Definition at line 268 of file Assembly.h.

{ return _current_JxW; }

Referenced by elementVolume(), reinitDual(), reinitLowerDElem(), and reinitNeighbor().

JxWFace()

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

inline

Returns the reference to the transformed jacobian weights on a current face.

Returns

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

Definition at line 343 of file Assembly.h.

{ return _current_JxW_face; }

Referenced by NonlinearThread::onInterfaceWithHRefinementMismatch().

jxWMortar()

const std::vector< Real > & Assembly::jxWMortar ( ) const

inline

Returns a reference to JxW for mortar segment elements.

Definition at line 699 of file Assembly.h.

{ return *_JxW_msm; }

Referenced by Moose::Mortar::loopOverMortarSegments().

JxWNeighbor()

const MooseArray< Real > & Assembly::JxWNeighbor

(

)

const

Returns the reference to the transformed jacobian weights on a current face.

Returns

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

Definition at line 260 of file Assembly.C.

{
  _need_JxW_neighbor = true;
  return _current_JxW_neighbor;
}

lowerDElem()

const Elem *const & Assembly::lowerDElem ( ) const

inline

Return the lower dimensional element.

Returns

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

Definition at line 468 of file Assembly.h.

{ return _current_lower_d_elem; }

Referenced by Moose::globalDofIndexToDerivative(), and MooseVariableFE< OutputType >::MooseVariableFE().

lowerDElemVolume()

const Real & Assembly::lowerDElemVolume ( ) const

inline

Definition at line 3204 of file Assembly.h.

{
  _need_lower_d_elem_volume = true;
  return _current_lower_d_elem_volume;
}

mappedNormals()

const std::vector< Eigen::Map< RealDIMValue > > & Assembly::mappedNormals ( ) const

inline

Definition at line 354 of file Assembly.h.

{ return _mapped_normals; }

modifyArbitraryWeights()

void Assembly::modifyArbitraryWeights

(

const std::vector< Real > &

weights

)

Modify the weights when using the arbitrary quadrature rule.

The intention is to use this when you wish to supply your own quadrature after calling reinit at physical points.

You should only use this if the arbitrary quadrature is the current quadrature rule!

Parameters

weights

The weights to fill into _current_JxW

Definition at line 4610 of file Assembly.C.

{
  mooseAssert(_current_qrule == _current_qrule_arbitrary, "Rule should be arbitrary");
  mooseAssert(weights.size() == _current_physical_points.size(), "Size mismatch");
 
  for (MooseIndex(weights.size()) i = 0; i < weights.size(); ++i)
    _current_JxW[i] = weights[i];
}

modifyFaceWeightsDueToXFEM()

void Assembly::modifyFaceWeightsDueToXFEM ( const Elem *  elem, unsigned int  side = 0  )

private

Update the face integration weights for XFEM partial elements.

This only affects the weights if XFEM is used and if the element is cut.

Parameters

elem	The element for which the weights are adjusted
side	The side of element for which the weights are adjusted

Definition at line 4589 of file Assembly.C.

{
  mooseAssert(_xfem != nullptr, "This function should not be called if xfem is inactive");
 
  if (_current_qrule_face == _current_qrule_arbitrary)
    return;
 
  MooseArray<Real> xfem_face_weight_multipliers;
  if (_xfem->getXFEMFaceWeights(
          xfem_face_weight_multipliers, elem, _current_qrule_face, _current_q_points_face, side))
  {
    mooseAssert(xfem_face_weight_multipliers.size() == _current_JxW_face.size(),
                "Size of weight multipliers in xfem doesn't match number of quadrature points");
    for (unsigned i = 0; i < xfem_face_weight_multipliers.size(); i++)
      _current_JxW_face[i] = _current_JxW_face[i] * xfem_face_weight_multipliers[i];
 
    xfem_face_weight_multipliers.release();
  }
}

Referenced by reinitFEFace().

modifyWeightsDueToXFEM()

void Assembly::modifyWeightsDueToXFEM ( const Elem *  elem )

private

Update the integration weights for XFEM partial elements.

This only affects the weights if XFEM is used and if the element is cut.

Parameters

elem	The element for which the weights are adjusted

Definition at line 4569 of file Assembly.C.

{
  mooseAssert(_xfem != nullptr, "This function should not be called if xfem is inactive");
 
  if (_current_qrule == _current_qrule_arbitrary)
    return;
 
  MooseArray<Real> xfem_weight_multipliers;
  if (_xfem->getXFEMWeights(xfem_weight_multipliers, elem, _current_qrule, _current_q_points))
  {
    mooseAssert(xfem_weight_multipliers.size() == _current_JxW.size(),
                "Size of weight multipliers in xfem doesn't match number of quadrature points");
    for (unsigned i = 0; i < xfem_weight_multipliers.size(); i++)
      _current_JxW[i] = _current_JxW[i] * xfem_weight_multipliers[i];
 
    xfem_weight_multipliers.release();
  }
}

Referenced by reinitFE().

mortarCoordTransformation()

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

inline

Returns the reference to the coordinate transformation coefficients on the mortar segment mesh.

Returns

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

Definition at line 286 of file Assembly.h.

{ return _coord_msm; }

Referenced by Moose::Mortar::loopOverMortarSegments().

msmElem()

const Elem *const & Assembly::msmElem ( ) const

inline

Returns

The current mortar segment element

Definition at line 1953 of file Assembly.h.

{ return _msm_elem; }

needADGradPhiFace()

void Assembly::needADGradPhiFace ( ) const

inline

Request that face reinitialization compute the AD shape function gradients.

Variables call this when an object needs their AD gradient or their AD face test function gradients.

Definition at line 1675 of file Assembly.h.

{ _need_ad_grad_phi_face = true; }

needDual()

bool Assembly::needDual ( ) const

inline

Indicates whether dual shape functions are used (computation is now repeated on each element so expense of computing dual shape functions is no longer trivial)

Definition at line 615 of file Assembly.h.

{ return _need_dual; }

Referenced by Moose::Mortar::loopOverMortarSegments().

neighbor()

const Elem *const & Assembly::neighbor ( ) const

inline

Return the neighbor element.

Returns

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

Definition at line 462 of file Assembly.h.

{ return _current_neighbor_elem; }

Referenced by Moose::globalDofIndexToDerivative(), MooseLinearVariableFV< OutputType >::MooseLinearVariableFV(), MooseVariableFE< OutputType >::MooseVariableFE(), MooseVariableFV< RealEigenVector >::MooseVariableFV(), qruleFaceHelper(), reinitElemAndNeighbor(), reinitFEFaceNeighbor(), reinitFENeighbor(), reinitNeighbor(), reinitNeighborAtPhysical(), reinitNeighborAtPhysical(), and reinitNeighborFaceRef().

neighborLowerDElem()

const Elem *const & Assembly::neighborLowerDElem ( ) const

inline

Return the neighboring lower dimensional element.

Returns

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

Definition at line 474 of file Assembly.h.

{ return _current_neighbor_lower_d_elem; }

neighborLowerDElemVolume()

const Real & Assembly::neighborLowerDElemVolume ( ) const

inline

Definition at line 3211 of file Assembly.h.

{
  _need_neighbor_lower_d_elem_volume = true;
  return _current_neighbor_lower_d_elem_volume;
}

neighborSide()

const unsigned int & Assembly::neighborSide ( ) const

inline

Returns the current neighboring side.

Returns

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

Definition at line 444 of file Assembly.h.

{ return _current_neighbor_side; }

neighborVolume()

const Real & Assembly::neighborVolume ( )

inline

Returns the reference to the current neighbor volume.

Returns

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

Definition at line 500 of file Assembly.h.

  {
    _need_neighbor_elem_volume = true;
    return _current_neighbor_volume;
  }

Referenced by InterfaceKernelBase::getNeighborElemVolume(), InternalSideUserObject::getNeighborElemVolume(), and DGKernelBase::getNeighborElemVolume().

node()

const Node *const & Assembly::node ( ) const

inline

Returns the reference to the node.

Returns

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

Definition at line 537 of file Assembly.h.

{ return _current_node; }

Referenced by computeFaceMap(), computeSinglePointMapAD(), MooseVariableFE< OutputType >::MooseVariableFE(), and reinit().

nodeNeighbor()

const Node *const & Assembly::nodeNeighbor ( ) const

inline

Returns the reference to the neighboring node.

Returns

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

Definition at line 543 of file Assembly.h.

{ return _current_neighbor_node; }

Referenced by MooseVariableFE< OutputType >::MooseVariableFE().

nonlocalCouplingEntries()

std::vector< std::pair< MooseVariableFieldBase *, MooseVariableFieldBase * > > & Assembly::nonlocalCouplingEntries ( )

inline

Definition at line 1296 of file Assembly.h.

  {
    return _cm_nonlocal_entry;
  }

normals()

const MooseArray< Point > & Assembly::normals ( ) const

inline

Returns the array of normals for quadrature points on a current side.

Returns

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

Definition at line 349 of file Assembly.h.

{ return _current_normals; }

numExtraElemIntegers()

unsigned int Assembly::numExtraElemIntegers ( ) const

inline

Number of extra element integers Assembly tracked.

Definition at line 365 of file Assembly.h.

{ return _extra_elem_ids.size() - 1; }

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

phi() [1/6]

const VariablePhiValue & Assembly::phi ( ) const

inline

Definition at line 1312 of file Assembly.h.

{ return _phi; }

Referenced by copyShapes().

phi() [2/6]

VariablePhiValue & Assembly::phi ( const MooseVariableField< Real > &  )

inline

Definition at line 1457 of file Assembly.h.

{ return _phi; }

phi() [3/6]

const VariablePhiValue & Assembly::phi ( const MooseVariableField< Real > &  ) const

inline

Definition at line 1318 of file Assembly.h.

{ return _phi; }

phi() [4/6]

VariablePhiValue & Assembly::phi ( const MooseVariableField< RealEigenVector > &  )

inline

Definition at line 1570 of file Assembly.h.

{ return _phi; }

phi() [5/6]

VectorVariablePhiValue & Assembly::phi ( const MooseVariableField< RealVectorValue > &  )

inline

Definition at line 1489 of file Assembly.h.

{ return _vector_phi; }

phi() [6/6]

const VectorVariablePhiValue & Assembly::phi ( const MooseVariableField< RealVectorValue > &  ) const

inline

Definition at line 1365 of file Assembly.h.

  {
    return _vector_phi;
  }

phiFace() [1/6]

const VariablePhiValue & Assembly::phiFace ( ) const

inline

Definition at line 1327 of file Assembly.h.

{ return _phi_face; }

Referenced by copyFaceShapes().

phiFace() [2/6]

VariablePhiValue & Assembly::phiFace ( const MooseVariableField< Real > &  )

inline

Definition at line 1461 of file Assembly.h.

{ return _phi_face; }

phiFace() [3/6]

const VariablePhiValue & Assembly::phiFace ( const MooseVariableField< Real > &  ) const

inline

Definition at line 1328 of file Assembly.h.

{ return _phi_face; }

phiFace() [4/6]

VariablePhiValue & Assembly::phiFace ( const MooseVariableField< RealEigenVector > &  )

inline

Definition at line 1574 of file Assembly.h.

{ return _phi_face; }

phiFace() [5/6]

VectorVariablePhiValue & Assembly::phiFace ( const MooseVariableField< RealVectorValue > &  )

inline

Definition at line 1507 of file Assembly.h.

  {
    return _vector_phi_face;
  }

phiFace() [6/6]

const VectorVariablePhiValue & Assembly::phiFace ( const MooseVariableField< RealVectorValue > &  ) const

inline

Definition at line 1386 of file Assembly.h.

  {
    return _vector_phi_face;
  }

phiFaceNeighbor() [1/5]

VariablePhiValue & Assembly::phiFaceNeighbor ( const MooseVariableField< Real > &  )

inline

Definition at line 1475 of file Assembly.h.

  {
    return _phi_face_neighbor;
  }

phiFaceNeighbor() [2/5]

const VariablePhiValue & Assembly::phiFaceNeighbor ( const MooseVariableField< Real > &  ) const

inline

Definition at line 1352 of file Assembly.h.

  {
    return _phi_face_neighbor;
  }

Referenced by copyNeighborShapes().

phiFaceNeighbor() [3/5]

VariablePhiValue & Assembly::phiFaceNeighbor ( const MooseVariableField< RealEigenVector > &  )

inline

Definition at line 1597 of file Assembly.h.

  {
    return _phi_face_neighbor;
  }

phiFaceNeighbor() [4/5]

VectorVariablePhiValue & Assembly::phiFaceNeighbor ( const MooseVariableField< RealVectorValue > &  )

inline

Definition at line 1548 of file Assembly.h.

  {
    return _vector_phi_face_neighbor;
  }

phiFaceNeighbor() [5/5]

const VectorVariablePhiValue & Assembly::phiFaceNeighbor ( const MooseVariableField< RealVectorValue > &  ) const

inline

Definition at line 1431 of file Assembly.h.

  {
    return _vector_phi_face_neighbor;
  }

phiNeighbor() [1/5]

VariablePhiValue & Assembly::phiNeighbor ( const MooseVariableField< Real > &  )

inline

Definition at line 1465 of file Assembly.h.

{ return _phi_neighbor; }

phiNeighbor() [2/5]

const VariablePhiValue & Assembly::phiNeighbor ( const MooseVariableField< Real > &  ) const

inline

Definition at line 1339 of file Assembly.h.

  {
    return _phi_neighbor;
  }

Referenced by copyNeighborShapes().

phiNeighbor() [3/5]

VariablePhiValue & Assembly::phiNeighbor ( const MooseVariableField< RealEigenVector > &  )

inline

Definition at line 1584 of file Assembly.h.

  {
    return _phi_neighbor;
  }

phiNeighbor() [4/5]

VectorVariablePhiValue & Assembly::phiNeighbor ( const MooseVariableField< RealVectorValue > &  )

inline

Definition at line 1528 of file Assembly.h.

  {
    return _vector_phi_neighbor;
  }

phiNeighbor() [5/5]

const VectorVariablePhiValue & Assembly::phiNeighbor ( const MooseVariableField< RealVectorValue > &  ) const

inline

Definition at line 1407 of file Assembly.h.

  {
    return _vector_phi_neighbor;
  }

physicalPoints()

const MooseArray< Point > & Assembly::physicalPoints ( ) const

inline

The current points in physical space where we have reinited through reinitAtPhysical()

Returns

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

Definition at line 262 of file Assembly.h.

{ return _current_physical_points; }

prepare()

void Assembly::prepare

(

)

Definition at line 2771 of file Assembly.C.

{
  prepareJacobianBlock();
  prepareResidual();
}

prepareBlock()

void Assembly::prepareBlock	(	unsigned int	ivar,
		unsigned	jvar,
		const std::vector< dof_id_type > &	dof_indices
	)

Definition at line 2954 of file Assembly.C.

{
  const auto & iv = _sys.getVariable(_tid, ivar);
  const auto & jv = _sys.getVariable(_tid, jvar);
  const unsigned int ivn = iv.number();
  const unsigned int jvn = jv.number();
  const unsigned int icount = iv.count();
  unsigned int jcount = jv.count();
  if (ivn == jvn && _component_block_diagonal[ivn])
    jcount = 1;
 
  for (MooseIndex(_jacobian_block_used) tag = 0; tag < _jacobian_block_used.size(); tag++)
  {
    jacobianBlock(ivn, jvn, LocalDataKey{}, tag)
        .resize(dof_indices.size() * icount, dof_indices.size() * jcount);
    jacobianBlockUsed(tag, ivn, jvn, false);
  }
 
  for (auto & tag_Re : _sub_Re)
    tag_Re[ivn].resize(dof_indices.size() * icount);
}

prepareBlockNonlocal()

void Assembly::prepareBlockNonlocal	(	unsigned int	ivar,
		unsigned	jvar,
		const std::vector< dof_id_type > &	idof_indices,
		const std::vector< dof_id_type > &	jdof_indices
	)

Definition at line 2979 of file Assembly.C.

{
  const auto & iv = _sys.getVariable(_tid, ivar);
  const auto & jv = _sys.getVariable(_tid, jvar);
  const unsigned int ivn = iv.number();
  const unsigned int jvn = jv.number();
  const unsigned int icount = iv.count();
  unsigned int jcount = jv.count();
  if (ivn == jvn && _component_block_diagonal[ivn])
    jcount = 1;
 
  for (MooseIndex(_jacobian_block_nonlocal_used) tag = 0;
       tag < _jacobian_block_nonlocal_used.size();
       tag++)
  {
    jacobianBlockNonlocal(ivn, jvn, LocalDataKey{}, tag)
        .resize(idof_indices.size() * icount, jdof_indices.size() * jcount);
 
    jacobianBlockNonlocalUsed(tag, ivn, jvn, false);
  }
}

prepareJacobianBlock()

void Assembly::prepareJacobianBlock

(

)

Sizes and zeroes the Jacobian blocks used for the current element.

Definition at line 2738 of file Assembly.C.

{
  for (const auto & it : _cm_ff_entry)
  {
    MooseVariableFEBase & ivar = *(it.first);
    MooseVariableFEBase & jvar = *(it.second);
 
    unsigned int vi = ivar.number();
    unsigned int vj = jvar.number();
 
    const bool array_block_diagonal_purely_diagonal = vi == vj && _component_block_diagonal[vi];
    auto num_cols = jvar.dofIndices().size();
    if (array_block_diagonal_purely_diagonal)
      num_cols /= jvar.count();
 
    for (MooseIndex(_jacobian_block_used) tag = 0; tag < _jacobian_block_used.size(); tag++)
    {
      jacobianBlock(vi, vj, LocalDataKey{}, tag).resize(ivar.dofIndices().size(), num_cols);
      jacobianBlockUsed(tag, vi, vj, false);
    }
  }
}

Referenced by prepare(), and reinitFVFace().

prepareLowerD()

void Assembly::prepareLowerD

(

)

Prepare the Jacobians and residuals for a lower dimensional element.

This method may be called when performing mortar finite element simulations

Definition at line 2902 of file Assembly.C.

{
  for (const auto & it : _cm_ff_entry)
  {
    MooseVariableFEBase & ivar = *(it.first);
    MooseVariableFEBase & jvar = *(it.second);
 
    unsigned int vi = ivar.number();
    unsigned int vj = jvar.number();
 
    const bool array_block_diagonal_purely_diagonal = vi == vj && _component_block_diagonal[vi];
    const auto dofs_divisor = array_block_diagonal_purely_diagonal ? jvar.count() : 1;
 
    for (MooseIndex(_jacobian_block_lower_used) tag = 0; tag < _jacobian_block_lower_used.size();
         tag++)
    {
      // To cover all possible cases we should have 9 combinations below for every 2-permutation
      // of Lower,Secondary,Primary. However, 4 cases will in general be covered by calls to
      // prepare() and prepareNeighbor(). These calls will cover SecondarySecondary
      // (ElementElement), SecondaryPrimary (ElementNeighbor), PrimarySecondary (NeighborElement),
      // and PrimaryPrimary (NeighborNeighbor). With these covered we only need to prepare the 5
      // remaining below
 
      // derivatives w.r.t. lower dimensional residuals
      jacobianBlockMortar(Moose::LowerLower, vi, vj, LocalDataKey{}, tag)
          .resize(ivar.dofIndicesLower().size(), jvar.dofIndicesLower().size() / dofs_divisor);
 
      jacobianBlockMortar(Moose::LowerSecondary, vi, vj, LocalDataKey{}, tag)
          .resize(ivar.dofIndicesLower().size(), jvar.dofIndices().size() / dofs_divisor);
 
      jacobianBlockMortar(Moose::LowerPrimary, vi, vj, LocalDataKey{}, tag)
          .resize(ivar.dofIndicesLower().size(), jvar.dofIndicesNeighbor().size() / dofs_divisor);
 
      // derivatives w.r.t. interior secondary residuals
      jacobianBlockMortar(Moose::SecondaryLower, vi, vj, LocalDataKey{}, tag)
          .resize(ivar.dofIndices().size(), jvar.dofIndicesLower().size() / dofs_divisor);
 
      // derivatives w.r.t. interior primary residuals
      jacobianBlockMortar(Moose::PrimaryLower, vi, vj, LocalDataKey{}, tag)
          .resize(ivar.dofIndicesNeighbor().size(), jvar.dofIndicesLower().size() / dofs_divisor);
 
      jacobianBlockLowerUsed(tag, vi, vj, false);
    }
  }
 
  const std::vector<MooseVariableFEBase *> & vars = _sys.getVariables(_tid);
  for (const auto & var : vars)
    for (auto & tag_Rl : _sub_Rl)
      tag_Rl[var->number()].resize(var->dofIndicesLower().size());
}

Referenced by SubProblem::reinitLowerDElem().

prepareNeighbor()

void Assembly::prepareNeighbor

(

)

Definition at line 2864 of file Assembly.C.

{
  for (const auto & it : _cm_ff_entry)
  {
    MooseVariableFEBase & ivar = *(it.first);
    MooseVariableFEBase & jvar = *(it.second);
 
    unsigned int vi = ivar.number();
    unsigned int vj = jvar.number();
 
    const bool array_block_diagonal_purely_diagonal = vi == vj && _component_block_diagonal[vi];
    const auto dofs_divisor = array_block_diagonal_purely_diagonal ? jvar.count() : 1;
 
    for (MooseIndex(_jacobian_block_neighbor_used) tag = 0;
         tag < _jacobian_block_neighbor_used.size();
         tag++)
    {
      jacobianBlockNeighbor(Moose::ElementNeighbor, vi, vj, LocalDataKey{}, tag)
          .resize(ivar.dofIndices().size(), jvar.dofIndicesNeighbor().size() / dofs_divisor);
 
      jacobianBlockNeighbor(Moose::NeighborElement, vi, vj, LocalDataKey{}, tag)
          .resize(ivar.dofIndicesNeighbor().size(), jvar.dofIndices().size() / dofs_divisor);
 
      jacobianBlockNeighbor(Moose::NeighborNeighbor, vi, vj, LocalDataKey{}, tag)
          .resize(ivar.dofIndicesNeighbor().size(),
                  jvar.dofIndicesNeighbor().size() / dofs_divisor);
 
      jacobianBlockNeighborUsed(tag, vi, vj, false);
    }
  }
 
  const std::vector<MooseVariableFEBase *> & vars = _sys.getVariables(_tid);
  for (const auto & var : vars)
    for (auto & tag_Rn : _sub_Rn)
      tag_Rn[var->number()].resize(var->dofIndicesNeighbor().size());
}

Referenced by SystemBase::prepareNeighbor(), reinitFVFace(), and SubProblem::reinitNeighborFaceRef().

prepareNonlocal()

void Assembly::prepareNonlocal

(

)

Definition at line 2778 of file Assembly.C.

{
  for (const auto & it : _cm_nonlocal_entry)
  {
    MooseVariableFEBase & ivar = *(it.first);
    MooseVariableFEBase & jvar = *(it.second);
 
    unsigned int vi = ivar.number();
    unsigned int vj = jvar.number();
 
    const bool array_block_diagonal_purely_diagonal = vi == vj && _component_block_diagonal[vi];
    auto num_cols = jvar.allDofIndices().size();
    if (array_block_diagonal_purely_diagonal)
      num_cols /= jvar.count();
 
    for (MooseIndex(_jacobian_block_nonlocal_used) tag = 0;
         tag < _jacobian_block_nonlocal_used.size();
         tag++)
    {
      jacobianBlockNonlocal(vi, vj, LocalDataKey{}, tag).resize(ivar.dofIndices().size(), num_cols);
      jacobianBlockNonlocalUsed(tag, vi, vj, false);
    }
  }
}

prepareOffDiagScalar()

void Assembly::prepareOffDiagScalar

(

)

Definition at line 3029 of file Assembly.C.

{
  const std::vector<MooseVariableFEBase *> & vars = _sys.getVariables(_tid);
  const std::vector<MooseVariableScalar *> & scalar_vars = _sys.getScalarVariables(_tid);
 
  for (const auto & ivar : scalar_vars)
  {
    auto idofs = ivar->dofIndices().size();
 
    for (const auto & jvar : vars)
    {
      auto jdofs = jvar->dofIndices().size() * jvar->count();
      for (MooseIndex(_jacobian_block_used) tag = 0; tag < _jacobian_block_used.size(); tag++)
      {
        jacobianBlock(ivar->number(), jvar->number(), LocalDataKey{}, tag).resize(idofs, jdofs);
        jacobianBlockUsed(tag, ivar->number(), jvar->number(), false);
 
        jacobianBlock(jvar->number(), ivar->number(), LocalDataKey{}, tag).resize(jdofs, idofs);
        jacobianBlockUsed(tag, jvar->number(), ivar->number(), false);
      }
    }
  }
}

Referenced by NodalScalarKernel::reinit().

preparePRefinement()

void Assembly::preparePRefinement

(

)

Prepare helper FEs for p-refinement.

The helper FEs are used for physical locations of quadrature points and JxW, and should not apply element p-levels to their own basis.

Definition at line 4887 of file Assembly.C.

{
  if (_prepared_for_p_refinement)
    // Already performed tasks for p-refinement
    return;
 
  const auto helper_type = _helper_type;
  auto process_fe_and_helpers = [&helper_type](auto & unique_helper_container,
                                               auto & helper_container,
                                               const unsigned int num_dimensionalities,
                                               const bool user_added_helper_type,
                                               auto & fe_container)
  {
    unique_helper_container.resize(num_dimensionalities);
    for (const auto dim : make_range(num_dimensionalities))
    {
      auto & unique_helper = unique_helper_container[dim];
      unique_helper = FEGenericBase<Real>::build(dim, helper_type);
      // don't participate in p-refinement
      unique_helper->add_p_level_in_reinit(false);
      helper_container[dim] = unique_helper.get();
 
      // If the user did not request the helper type then we should erase the original helper FE
      // from the ordinary FE container. The unique helper above replaces it for helper use.
      if (!user_added_helper_type)
      {
        auto & fe_container_dim = libmesh_map_find(fe_container, dim);
        auto fe_it = fe_container_dim.find(helper_type);
        mooseAssert(fe_it != fe_container_dim.end(), "We should have the helper type");
        delete fe_it->second;
        fe_container_dim.erase(fe_it);
      }
    }
  };
 
  // Handle scalar field families
  process_fe_and_helpers(_unique_fe_helper,
                         _holder_fe_helper,
                         _mesh_dimension + 1,
                         _user_added_fe_of_helper_type,
                         _fe);
  process_fe_and_helpers(_unique_fe_face_helper,
                         _holder_fe_face_helper,
                         _mesh_dimension + 1,
                         _user_added_fe_face_of_helper_type,
                         _fe_face);
  process_fe_and_helpers(_unique_fe_face_neighbor_helper,
                         _holder_fe_face_neighbor_helper,
                         _mesh_dimension + 1,
                         _user_added_fe_face_neighbor_of_helper_type,
                         _fe_face_neighbor);
  process_fe_and_helpers(_unique_fe_neighbor_helper,
                         _holder_fe_neighbor_helper,
                         _mesh_dimension + 1,
                         _user_added_fe_neighbor_of_helper_type,
                         _fe_neighbor);
  process_fe_and_helpers(_unique_fe_lower_helper,
                         _holder_fe_lower_helper,
                         _mesh_dimension,
                         _user_added_fe_lower_of_helper_type,
                         _fe_lower);
 
  helpersRequestData();
 
  _prepared_for_p_refinement = true;
}

Referenced by SubProblem::preparePRefinement().

prepareResidual()

void Assembly::prepareResidual

(

)

Sizes and zeroes the residual for the current element.

Definition at line 2762 of file Assembly.C.

{
  const std::vector<MooseVariableFEBase *> & vars = _sys.getVariables(_tid);
  for (const auto & var : vars)
    for (auto & tag_Re : _sub_Re)
      tag_Re[var->number()].resize(var->dofIndices().size());
}

Referenced by prepare(), and reinitFVFace().

prepareScalar()

void Assembly::prepareScalar

(

)

Definition at line 3005 of file Assembly.C.

{
  const std::vector<MooseVariableScalar *> & vars = _sys.getScalarVariables(_tid);
  for (const auto & ivar : vars)
  {
    auto idofs = ivar->dofIndices().size();
 
    for (auto & tag_Re : _sub_Re)
      tag_Re[ivar->number()].resize(idofs);
 
    for (const auto & jvar : vars)
    {
      auto jdofs = jvar->dofIndices().size();
 
      for (MooseIndex(_jacobian_block_used) tag = 0; tag < _jacobian_block_used.size(); tag++)
      {
        jacobianBlock(ivar->number(), jvar->number(), LocalDataKey{}, tag).resize(idofs, jdofs);
        jacobianBlockUsed(tag, ivar->number(), jvar->number(), false);
      }
    }
  }
}

Referenced by FEProblemBase::reinitScalars().

prepareVariable()

void Assembly::prepareVariable

(

MooseVariableFieldBase *

var

)

Used for preparing the dense residual and jacobian blocks for one particular variable.

Parameters

var	The variable that needs to have its datastructures prepared

Definition at line 2804 of file Assembly.C.

{
  for (const auto & it : _cm_ff_entry)
  {
    MooseVariableFEBase & ivar = *(it.first);
    MooseVariableFEBase & jvar = *(it.second);
 
    unsigned int vi = ivar.number();
    unsigned int vj = jvar.number();
 
    const bool array_block_diagonal_purely_diagonal = vi == vj && _component_block_diagonal[vi];
    auto num_cols = jvar.dofIndices().size();
    if (array_block_diagonal_purely_diagonal)
      num_cols /= jvar.count();
 
    if (vi == var->number() || vj == var->number())
    {
      for (MooseIndex(_jacobian_block_used) tag = 0; tag < _jacobian_block_used.size(); tag++)
      {
        jacobianBlock(vi, vj, LocalDataKey{}, tag).resize(ivar.dofIndices().size(), num_cols);
        jacobianBlockUsed(tag, vi, vj, false);
      }
    }
  }
 
  for (auto & tag_Re : _sub_Re)
    tag_Re[var->number()].resize(var->dofIndices().size());
}

prepareVariableNonlocal()

void Assembly::prepareVariableNonlocal

(

MooseVariableFieldBase *

var

)

Definition at line 2834 of file Assembly.C.

{
  for (const auto & it : _cm_nonlocal_entry)
  {
    MooseVariableFEBase & ivar = *(it.first);
    MooseVariableFEBase & jvar = *(it.second);
 
    unsigned int vi = ivar.number();
    unsigned int vj = jvar.number();
 
    const bool array_block_diagonal_purely_diagonal = vi == vj && _component_block_diagonal[vi];
    auto num_cols = jvar.dofIndices().size();
    if (array_block_diagonal_purely_diagonal)
      num_cols /= jvar.count();
 
    if (vi == var->number() || vj == var->number())
    {
      for (MooseIndex(_jacobian_block_nonlocal_used) tag = 0;
           tag < _jacobian_block_nonlocal_used.size();
           tag++)
      {
        jacobianBlockNonlocal(vi, vj, LocalDataKey{}, tag)
            .resize(ivar.dofIndices().size(), num_cols);
        jacobianBlockNonlocalUsed(tag, vi, vj);
      }
    }
  }
}

processLocalResidual()

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

private

Appling scaling, constraints to the local residual block and populate the full DoF indices for array variable.

Definition at line 3273 of file Assembly.C.

{
  mooseAssert(res_block.size() == dof_indices.size(),
              "The size of residual and degree of freedom container must be the same");
 
  // For an array variable, ndof is the number of dofs of the zero-th component and
  // ntdof is the number of dofs of all components.
  // For standard or vector variables, ndof will be the same as ntdof.
  const auto ntdof = res_block.size();
  const auto count = scaling_factor.size();
  const auto ndof = ntdof / count;
  if (count > 1)
  {
    unsigned int p = 0;
    for (MooseIndex(count) j = 0; j < count; ++j)
      for (MooseIndex(ndof) i = 0; i < ndof; ++i)
        res_block(p++) *= scaling_factor[j];
  }
  else
  {
    if (scaling_factor[0] != 1.0)
      res_block *= scaling_factor[0];
  }
 
  _dof_map.constrain_element_vector(res_block, dof_indices, false);
}

Referenced by addResidualBlock(), cacheResidualBlock(), and setResidualBlock().

qPoints()

const MooseArray< Point > & Assembly::qPoints ( ) const

inline

Returns the reference to the quadrature points.

Returns

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

Definition at line 250 of file Assembly.h.

{ return _current_q_points; }

Referenced by genericQPoints().

qPointsFace()

const MooseArray< Point > & Assembly::qPointsFace ( ) const

inline

Returns the reference to the current quadrature being used.

Returns

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

Definition at line 337 of file Assembly.h.

{ return _current_q_points_face; }

Referenced by GeometricSearchData::generateQuadratureNodes(), NonlinearThread::onInterfaceWithHRefinementMismatch(), and GeometricSearchData::updateQuadratureNodes().

qPointsFaceNeighbor()

const MooseArray< Point > & Assembly::qPointsFaceNeighbor ( ) const

inline

Returns the reference to the current quadrature points being used on the neighbor face.

Returns

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

Definition at line 531 of file Assembly.h.

{ return _current_q_points_face_neighbor; }

qPointsMortar()

const std::vector< Point > & Assembly::qPointsMortar ( ) const

inline

Returns the reference to the mortar segment element quadrature points.

Returns

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

Definition at line 256 of file Assembly.h.

{ return _fe_msm->get_xyz(); }

qRule()

const libMesh::QBase *const & Assembly::qRule ( ) const

inline

Returns the reference to the current quadrature being used.

Returns

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

Definition at line 227 of file Assembly.h.

{ return constify_ref(_current_qrule); }

Referenced by MooseVariableFE< OutputType >::MooseVariableFE().

qruleArbitraryFace()

ArbitraryQuadrature * Assembly::qruleArbitraryFace ( const Elem *  elem, unsigned int  side  )

private

Definition at line 1962 of file Assembly.C.

{
  return qruleFaceHelper<ArbitraryQuadrature>(
      elem, side, [](QRules & q) { return q.arbitrary_face.get(); });
}

Referenced by reinit(), and reinitElemFaceRef().

qRuleFace()

const libMesh::QBase *const & Assembly::qRuleFace ( ) const

inline

Returns the reference to the current quadrature being used on a current face.

Returns

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

Definition at line 314 of file Assembly.h.

{ return constify_ref(_current_qrule_face); }

Referenced by MooseVariableFE< OutputType >::MooseVariableFE().

qruleFace()

QBase * Assembly::qruleFace ( const Elem *  elem, unsigned int  side  )

private

This is an abstraction over the internal qrules function.

This is necessary for faces because (nodes of) faces can exists in more than one subdomain. When this is the case, we need to use the quadrature rule from the subdomain that has the highest specified quadrature order. So when you need to access a face quadrature rule, you should retrieve it via this function.

Definition at line 1956 of file Assembly.C.

{
  return qruleFaceHelper<QBase>(elem, side, [](QRules & q) { return q.face.get(); });
}

Referenced by reinitElemFaceRef(), and setFaceQRule().

qruleFaceHelper()

template<typename T >

T * Assembly::qruleFaceHelper ( const Elem *  elem, unsigned int  side, std::function< T *(QRules &)>  rule_fn  )

inlineprivate

Definition at line 2459 of file Assembly.h.

  {
    auto dim = elem->dim();
    auto neighbor = elem->neighbor_ptr(side);
    auto q = rule_fn(qrules(dim, elem->subdomain_id()));
    if (!neighbor)
      return q;
 
    // find the maximum face quadrature order for all blocks the face is in
    auto neighbor_block = neighbor->subdomain_id();
    if (neighbor_block == elem->subdomain_id())
      return q;
 
    auto q_neighbor = rule_fn(qrules(dim, neighbor_block));
    if (q->get_order() > q_neighbor->get_order())
      return q;
    return q_neighbor;
  }

qRuleMortar()

const libMesh::QBase *const & Assembly::qRuleMortar ( ) const

inline

Returns a reference to the quadrature rule for the mortar segments.

Definition at line 704 of file Assembly.h.

{ return constify_ref(_qrule_msm); }

Referenced by Moose::Mortar::loopOverMortarSegments().

qRuleNeighbor()

const libMesh::QBase *const & Assembly::qRuleNeighbor ( ) const

inline

Returns the reference to the current quadrature being used on a current neighbor.

Returns

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

Definition at line 510 of file Assembly.h.

  {
    return constify_ref(_current_qrule_neighbor);
  }

Referenced by MooseVariableFE< OutputType >::MooseVariableFE().

qrules() [1/2]

QRules & Assembly::qrules ( unsigned int  dim )

inlineprivate

Definition at line 2478 of file Assembly.h.

{ return qrules(dim, _current_subdomain_id); }

Referenced by attachQRuleElem(), attachQRuleFace(), qruleFaceHelper(), qrules(), reinit(), reinitFVFace(), reinitLowerDElem(), reinitNeighbor(), reinitNeighborFaceRef(), setVolumeQRule(), writeableQRule(), and writeableQRuleFace().

qrules() [2/2]

QRules & Assembly::qrules ( unsigned int  dim, SubdomainID  block  )

inlineprivate

This is a helper function for accessing quadrature rules for a particular dimensionality of element.

All access to quadrature rules in Assembly should be done via this accessor function.

Definition at line 2483 of file Assembly.h.

  {
    if (_qrules.find(block) == _qrules.end())
    {
      mooseAssert(_qrules.find(Moose::ANY_BLOCK_ID) != _qrules.end(),
                  "missing quadrature rules for specified block");
      mooseAssert(_qrules[Moose::ANY_BLOCK_ID].size() > dim,
                  "quadrature rules not sized property for dimension");
      return _qrules[Moose::ANY_BLOCK_ID][dim];
    }
    mooseAssert(_qrules.find(block) != _qrules.end(),
                "missing quadrature rules for specified block");
    mooseAssert(_qrules[block].size() > dim, "quadrature rules not sized property for dimension");
    return _qrules[block][dim];
  }

reinit() [1/5]

void Assembly::reinit

(

const Elem *

elem

)

Reinitialize objects (JxW, q_points, ...) for an elements.

Parameters

elem	The element we want to reinitialize on

Definition at line 1858 of file Assembly.C.

{
  _current_elem = elem;
  _current_neighbor_elem = nullptr;
  mooseAssert(_current_subdomain_id == _current_elem->subdomain_id(),
              "current subdomain has been set incorrectly");
  _current_elem_volume_computed = false;
  setVolumeQRule(elem);
  reinitFE(elem);
 
  computeCurrentElemVolume();
}

Referenced by MooseMesh::buildHRefinementAndCoarseningMaps(), MooseMesh::buildPRefinementAndCoarseningMaps(), GeometricSearchData::generateQuadratureNodes(), ComputeBoundaryInitialConditionThread::onNode(), reinitAtPhysical(), reinitElemAndNeighbor(), and GeometricSearchData::updateQuadratureNodes().

reinit() [2/5]

void Assembly::reinit	(	const Elem *	elem,
		const std::vector< Point > &	reference_points
	)

Reinitialize the assembly data at specific points in the reference element.

Definition at line 1872 of file Assembly.C.

{
  _current_elem = elem;
  _current_neighbor_elem = nullptr;
  mooseAssert(_current_subdomain_id == _current_elem->subdomain_id(),
              "current subdomain has been set incorrectly");
  _current_elem_volume_computed = false;
 
  unsigned int elem_dimension = _current_elem->dim();
 
  _current_qrule_arbitrary = qrules(elem_dimension).arbitrary_vol.get();
 
  // Make sure the qrule is the right one
  if (_current_qrule != _current_qrule_arbitrary)
    setVolumeQRule(_current_qrule_arbitrary, elem_dimension);
 
  _current_qrule_arbitrary->setPoints(reference_points);
 
  reinitFE(elem);
 
  computeCurrentElemVolume();
}

reinit() [3/5]

void Assembly::reinit	(	const Elem *	elem,
		unsigned int	side
	)

Reinitialize the assembly data on an side of an element.

Definition at line 1979 of file Assembly.C.

{
  _current_elem = elem;
  _current_neighbor_elem = nullptr;
  mooseAssert(_current_subdomain_id == _current_elem->subdomain_id(),
              "current subdomain has been set incorrectly");
  _current_side = side;
  _current_elem_volume_computed = false;
  _current_side_volume_computed = false;
 
  _current_side_elem = &_current_side_elem_builder(*elem, side);
 
  setFaceQRule(elem, side);
  reinitFEFace(elem, side);
 
  computeCurrentFaceVolume();
}

reinit() [4/5]

void Assembly::reinit	(	const Elem *	elem,
		unsigned int	side,
		const std::vector< Point > &	reference_points
	)

Reinitialize the assembly data on the side of a element at the custom reference points.

Definition at line 1998 of file Assembly.C.

{
  _current_elem = elem;
  _current_neighbor_elem = nullptr;
  mooseAssert(_current_subdomain_id == _current_elem->subdomain_id(),
              "current subdomain has been set incorrectly");
  _current_side = side;
  _current_elem_volume_computed = false;
  _current_side_volume_computed = false;
 
  unsigned int elem_dimension = _current_elem->dim();
 
  _current_qrule_arbitrary_face = qruleArbitraryFace(elem, side);
 
  // Make sure the qrule is the right one
  if (_current_qrule_face != _current_qrule_arbitrary_face)
    setFaceQRule(_current_qrule_arbitrary_face, elem_dimension);
 
  _current_qrule_arbitrary->setPoints(reference_points);
 
  _current_side_elem = &_current_side_elem_builder(*elem, side);
 
  reinitFEFace(elem, side);
 
  computeCurrentFaceVolume();
}

reinit() [5/5]

void Assembly::reinit

(

const Node *

node

)

Reinitialize assembly data for a node.

Definition at line 2026 of file Assembly.C.

{
  _current_node = node;
  _current_neighbor_node = NULL;
}

reinitAtPhysical()

void Assembly::reinitAtPhysical	(	const Elem *	elem,
		const std::vector< Point > &	physical_points
	)

Reinitialize the assembly data at specific physical point in the given element.

Definition at line 1831 of file Assembly.C.

{
  _current_elem = elem;
  _current_neighbor_elem = nullptr;
  mooseAssert(_current_subdomain_id == _current_elem->subdomain_id(),
              "current subdomain has been set incorrectly");
  _current_elem_volume_computed = false;
 
  FEMap::inverse_map(elem->dim(), elem, physical_points, _temp_reference_points);
 
  reinit(elem, _temp_reference_points);
 
  // Save off the physical points
  _current_physical_points = physical_points;
}

reinitDual()

void Assembly::reinitDual	(	const Elem *	elem,
		const std::vector< Point > &	pts,
		const std::vector< Real > &	JxW
	)

Reintialize dual basis coefficients based on a customized quadrature rule.

Definition at line 2323 of file Assembly.C.

{
  const unsigned int elem_dim = elem->dim();
  mooseAssert(elem_dim == _mesh_dimension - 1,
              "Dual shape functions should only be computed on lower dimensional face elements");
 
  for (const auto & [fe_type, fe_lower] : _fe_lower[elem_dim])
  {
    const auto dual_shape_data = _fe_shape_data_dual_lower.find(fe_type);
    if (dual_shape_data == _fe_shape_data_dual_lower.end() || !dual_shape_data->second)
      continue;
 
    // We use customized quadrature rule for integration along the mortar segment elements
    fe_lower->set_calculate_default_dual_coeff(false);
    fe_lower->reinit_dual_shape_coeffs(elem, pts, JxW);
  }
}

Referenced by Moose::Mortar::loopOverMortarSegments().

reinitElemAndNeighbor()

void Assembly::reinitElemAndNeighbor	(	const Elem *	elem,
		unsigned int	side,
		const Elem *	neighbor,
		unsigned int	neighbor_side,
		const std::vector< Point > *	neighbor_reference_points = nullptr
	)

Reinitialize an element and its neighbor along a particular side.

Parameters

elem	Element being reinitialized
side	Side of the element
neighbor	Neighbor facing the element on the side 'side'
neighbor_side	The side id on the neighboring element.
neighbor_reference_points	Optional argument specifying the neighbor reference points. If not passed, then neighbor reference points will be determined by doing an inverse map based on the physical location of the elem quadrature points

Definition at line 2033 of file Assembly.C.

{
  _current_neighbor_side = neighbor_side;
 
  reinit(elem, side);
 
  unsigned int neighbor_dim = neighbor->dim();
 
  if (neighbor_reference_points)
    _current_neighbor_ref_points = *neighbor_reference_points;
  else
    FEMap::inverse_map(
        neighbor_dim, neighbor, _current_q_points_face.stdVector(), _current_neighbor_ref_points);
 
  _current_neighbor_side_elem = &_current_neighbor_side_elem_builder(*neighbor, neighbor_side);
 
  reinitFEFaceNeighbor(neighbor, _current_neighbor_ref_points);
  reinitNeighbor(neighbor, _current_neighbor_ref_points);
}

reinitElemFaceRef()

void Assembly::reinitElemFaceRef	(	const Elem *	elem,
		unsigned int	elem_side,
		Real	tolerance,
		const std::vector< Point > *const	pts = nullptr,
		const std::vector< Real > *const	weights = nullptr
	)

Reinitialize FE data for the given element on the given side, optionally with a given set of reference points.

Definition at line 2058 of file Assembly.C.

{
  _current_elem = elem;
 
  unsigned int elem_dim = elem->dim();
 
  // Attach the quadrature rules
  if (pts)
  {
    auto face_rule = qruleArbitraryFace(elem, elem_side);
    face_rule->setPoints(*pts);
    setFaceQRule(face_rule, elem_dim);
  }
  else
  {
    auto rule = qruleFace(elem, elem_side);
    if (_current_qrule_face != rule)
      setFaceQRule(rule, elem_dim);
  }
 
  // reinit face
  for (const auto & it : _fe_face[elem_dim])
  {
    FEBase & fe_face = *it.second;
    FEType fe_type = it.first;
    FEShapeData & fesd = *_fe_shape_data_face[fe_type];
 
    fe_face.reinit(elem, elem_side, tolerance, pts, weights);
 
    _current_fe_face[fe_type] = &fe_face;
 
    fesd._phi.shallowCopy(const_cast<std::vector<std::vector<Real>> &>(fe_face.get_phi()));
    fesd._grad_phi.shallowCopy(
        const_cast<std::vector<std::vector<RealGradient>> &>(fe_face.get_dphi()));
    if (_need_second_derivative_neighbor.count(fe_type))
      fesd._second_phi.shallowCopy(
          const_cast<std::vector<std::vector<TensorValue<Real>>> &>(fe_face.get_d2phi()));
  }
  for (const auto & it : _vector_fe_face[elem_dim])
  {
    FEVectorBase & fe_face = *it.second;
    const FEType & fe_type = it.first;
 
    _current_vector_fe_face[fe_type] = &fe_face;
 
    VectorFEShapeData & fesd = *_vector_fe_shape_data_face[fe_type];
 
    fe_face.reinit(elem, elem_side, tolerance, pts, weights);
 
    fesd._phi.shallowCopy(
        const_cast<std::vector<std::vector<VectorValue<Real>>> &>(fe_face.get_phi()));
    fesd._grad_phi.shallowCopy(
        const_cast<std::vector<std::vector<TensorValue<Real>>> &>(fe_face.get_dphi()));
    if (_need_second_derivative.count(fe_type))
      fesd._second_phi.shallowCopy(
          const_cast<std::vector<std::vector<TypeNTensor<3, Real>>> &>(fe_face.get_d2phi()));
    if (_need_curl.count(fe_type))
      fesd._curl_phi.shallowCopy(
          const_cast<std::vector<std::vector<VectorValue<Real>>> &>(fe_face.get_curl_phi()));
    if (_need_face_div.count(fe_type))
      fesd._div_phi.shallowCopy(
          const_cast<std::vector<std::vector<Real>> &>(fe_face.get_div_phi()));
  }
  if (!_unique_fe_face_helper.empty())
  {
    mooseAssert(elem_dim < _unique_fe_face_helper.size(), "We should be in bounds here");
    _unique_fe_face_helper[elem_dim]->reinit(elem, elem_side, tolerance, pts, weights);
  }
 
  // During that last loop the helper objects will have been reinitialized
  _current_q_points_face.shallowCopy(
      const_cast<std::vector<Point> &>(_holder_fe_face_helper[elem_dim]->get_xyz()));
  _current_normals.shallowCopy(
      const_cast<std::vector<Point> &>(_holder_fe_face_helper[elem_dim]->get_normals()));
  _current_tangents.shallowCopy(const_cast<std::vector<std::vector<Point>> &>(
      _holder_fe_face_helper[elem_dim]->get_tangents()));
  // Note that if the user did pass in points and not weights to this method, JxW will be garbage
  // and should not be used
  _current_JxW_face.shallowCopy(
      const_cast<std::vector<Real> &>(_holder_fe_face_helper[elem_dim]->get_JxW()));
  if (_calculate_curvatures)
    _curvatures.shallowCopy(
        const_cast<std::vector<Real> &>(_holder_fe_face_helper[elem_dim]->get_curvatures()));
 
  computeADFace(*elem, elem_side);
 
  // Keep the current-side bookkeeping consistent with the other elem/side reinit overloads so
  // that consumers of _current_side, _current_side_elem, and _current_side_volume (e.g.
  // InterfaceKernelBase) see correct values rather than whatever was left over from a previous
  // reinit.
  _current_side = elem_side;
  _current_side_elem = &_current_side_elem_builder(*elem, elem_side);
  _current_side_volume_computed = false;
  computeCurrentFaceVolume();
}

Referenced by NonlinearThread::onInterfaceWithHRefinementMismatch(), and SubProblem::reinitElemFaceRef().

reinitFE()

void Assembly::reinitFE ( const Elem *  elem )

private

Just an internal helper function to reinit the volume FE objects.

Parameters

elem	The element we are using to reinit

Definition at line 797 of file Assembly.C.

{
  unsigned int dim = elem->dim();
 
  for (const auto & it : _fe[dim])
  {
    FEBase & fe = *it.second;
    const FEType & fe_type = it.first;
 
    _current_fe[fe_type] = &fe;
 
    FEShapeData & fesd = *_fe_shape_data[fe_type];
 
    fe.reinit(elem);
 
    fesd._phi.shallowCopy(const_cast<std::vector<std::vector<Real>> &>(fe.get_phi()));
    fesd._grad_phi.shallowCopy(
        const_cast<std::vector<std::vector<VectorValue<Real>>> &>(fe.get_dphi()));
    if (_need_second_derivative.count(fe_type))
      fesd._second_phi.shallowCopy(
          const_cast<std::vector<std::vector<TensorValue<Real>>> &>(fe.get_d2phi()));
  }
  for (const auto & it : _vector_fe[dim])
  {
    FEVectorBase & fe = *it.second;
    const FEType & fe_type = it.first;
 
    _current_vector_fe[fe_type] = &fe;
 
    VectorFEShapeData & fesd = *_vector_fe_shape_data[fe_type];
 
    fe.reinit(elem);
 
    fesd._phi.shallowCopy(const_cast<std::vector<std::vector<VectorValue<Real>>> &>(fe.get_phi()));
    fesd._grad_phi.shallowCopy(
        const_cast<std::vector<std::vector<TensorValue<Real>>> &>(fe.get_dphi()));
    if (_need_second_derivative.count(fe_type))
      fesd._second_phi.shallowCopy(
          const_cast<std::vector<std::vector<TypeNTensor<3, Real>>> &>(fe.get_d2phi()));
    if (_need_curl.count(fe_type))
      fesd._curl_phi.shallowCopy(
          const_cast<std::vector<std::vector<VectorValue<Real>>> &>(fe.get_curl_phi()));
    if (_need_div.count(fe_type))
      fesd._div_phi.shallowCopy(const_cast<std::vector<std::vector<Real>> &>(fe.get_div_phi()));
  }
  if (!_unique_fe_helper.empty())
  {
    mooseAssert(dim < _unique_fe_helper.size(), "We should be in bounds here");
    _unique_fe_helper[dim]->reinit(elem);
  }
 
  // During that last loop the helper objects will have been reinitialized as well
  // We need to dig out the q_points and JxW from it.
  _current_q_points.shallowCopy(
      const_cast<std::vector<Point> &>(_holder_fe_helper[dim]->get_xyz()));
  _current_JxW.shallowCopy(const_cast<std::vector<Real> &>(_holder_fe_helper[dim]->get_JxW()));
 
  if (_subproblem.haveADObjects())
  {
    auto n_qp = _current_qrule->n_points();
    resizeADMappingObjects(n_qp, dim);
    if (_displaced)
    {
      const auto & qw = _current_qrule->get_weights();
      for (unsigned int qp = 0; qp != n_qp; qp++)
        computeSinglePointMapAD(elem, qw, qp, _holder_fe_helper[dim]);
    }
    else
    {
      for (unsigned qp = 0; qp < n_qp; ++qp)
        _ad_JxW[qp] = _current_JxW[qp];
      if (_calculate_xyz)
        for (unsigned qp = 0; qp < n_qp; ++qp)
          _ad_q_points[qp] = _current_q_points[qp];
    }
 
    for (const auto & it : _fe[dim])
    {
      FEBase & fe = *it.second;
      auto fe_type = it.first;
      auto num_shapes = FEInterface::n_shape_functions(fe_type, elem);
      auto & grad_phi = _ad_grad_phi_data[fe_type];
 
      grad_phi.resize(num_shapes);
      for (decltype(num_shapes) i = 0; i < num_shapes; ++i)
        grad_phi[i].resize(n_qp);
 
      if (_displaced)
        computeGradPhiAD(elem, n_qp, grad_phi, &fe);
      else
      {
        const auto & regular_grad_phi = _fe_shape_data[fe_type]->_grad_phi;
        for (decltype(num_shapes) i = 0; i < num_shapes; ++i)
          for (unsigned qp = 0; qp < n_qp; ++qp)
            grad_phi[i][qp] = regular_grad_phi[i][qp];
      }
    }
    for (const auto & it : _vector_fe[dim])
    {
      FEVectorBase & fe = *it.second;
      auto fe_type = it.first;
      auto num_shapes = FEInterface::n_shape_functions(fe_type, elem);
      auto & grad_phi = _ad_vector_grad_phi_data[fe_type];
 
      grad_phi.resize(num_shapes);
      for (decltype(num_shapes) i = 0; i < num_shapes; ++i)
        grad_phi[i].resize(n_qp);
 
      if (_displaced)
        computeGradPhiAD(elem, n_qp, grad_phi, &fe);
      else
      {
        const auto & regular_grad_phi = _vector_fe_shape_data[fe_type]->_grad_phi;
        for (decltype(num_shapes) i = 0; i < num_shapes; ++i)
          for (unsigned qp = 0; qp < n_qp; ++qp)
            grad_phi[i][qp] = regular_grad_phi[i][qp];
      }
    }
  }
 
  auto n = numExtraElemIntegers();
  for (auto i : make_range(n))
    _extra_elem_ids[i] = _current_elem->get_extra_integer(i);
  _extra_elem_ids[n] = _current_elem->subdomain_id();
 
  if (_xfem != nullptr)
    modifyWeightsDueToXFEM(elem);
}

Referenced by reinit(), and reinit().

reinitFEFace()

void Assembly::reinitFEFace ( const Elem *  elem, unsigned int  side  )

private

Just an internal helper function to reinit the face FE objects.

Parameters

elem	The element we are using to reinit
side	The side of the element we are reiniting on

Definition at line 1307 of file Assembly.C.

{
  unsigned int dim = elem->dim();
 
  for (const auto & it : _fe_face[dim])
  {
    FEBase & fe_face = *it.second;
    const FEType & fe_type = it.first;
    FEShapeData & fesd = *_fe_shape_data_face[fe_type];
    fe_face.reinit(elem, side);
    _current_fe_face[fe_type] = &fe_face;
 
    fesd._phi.shallowCopy(const_cast<std::vector<std::vector<Real>> &>(fe_face.get_phi()));
    fesd._grad_phi.shallowCopy(
        const_cast<std::vector<std::vector<VectorValue<Real>>> &>(fe_face.get_dphi()));
    if (_need_second_derivative.count(fe_type))
      fesd._second_phi.shallowCopy(
          const_cast<std::vector<std::vector<TensorValue<Real>>> &>(fe_face.get_d2phi()));
  }
  for (const auto & it : _vector_fe_face[dim])
  {
    FEVectorBase & fe_face = *it.second;
    const FEType & fe_type = it.first;
 
    _current_vector_fe_face[fe_type] = &fe_face;
 
    VectorFEShapeData & fesd = *_vector_fe_shape_data_face[fe_type];
 
    fe_face.reinit(elem, side);
 
    fesd._phi.shallowCopy(
        const_cast<std::vector<std::vector<VectorValue<Real>>> &>(fe_face.get_phi()));
    fesd._grad_phi.shallowCopy(
        const_cast<std::vector<std::vector<TensorValue<Real>>> &>(fe_face.get_dphi()));
    if (_need_second_derivative.count(fe_type))
      fesd._second_phi.shallowCopy(
          const_cast<std::vector<std::vector<TypeNTensor<3, Real>>> &>(fe_face.get_d2phi()));
    if (_need_curl.count(fe_type))
      fesd._curl_phi.shallowCopy(
          const_cast<std::vector<std::vector<VectorValue<Real>>> &>(fe_face.get_curl_phi()));
    if (_need_face_div.count(fe_type))
      fesd._div_phi.shallowCopy(
          const_cast<std::vector<std::vector<Real>> &>(fe_face.get_div_phi()));
  }
  if (!_unique_fe_face_helper.empty())
  {
    mooseAssert(dim < _unique_fe_face_helper.size(), "We should be in bounds here");
    _unique_fe_face_helper[dim]->reinit(elem, side);
  }
 
  // During that last loop the helper objects will have been reinitialized as well
  // We need to dig out the q_points and JxW from it.
  _current_q_points_face.shallowCopy(
      const_cast<std::vector<Point> &>(_holder_fe_face_helper[dim]->get_xyz()));
  _current_JxW_face.shallowCopy(
      const_cast<std::vector<Real> &>(_holder_fe_face_helper[dim]->get_JxW()));
  _current_normals.shallowCopy(
      const_cast<std::vector<Point> &>(_holder_fe_face_helper[dim]->get_normals()));
 
  _mapped_normals.resize(_current_normals.size(), Eigen::Map<RealDIMValue>(nullptr));
  for (unsigned int i = 0; i < _current_normals.size(); i++)
    // Note: this does NOT do any allocation.  It is "reconstructing" the object in place
    new (&_mapped_normals[i]) Eigen::Map<RealDIMValue>(const_cast<Real *>(&_current_normals[i](0)));
 
  if (_calculate_curvatures)
    _curvatures.shallowCopy(
        const_cast<std::vector<Real> &>(_holder_fe_face_helper[dim]->get_curvatures()));
 
  computeADFace(*elem, side);
 
  if (_xfem != nullptr)
    modifyFaceWeightsDueToXFEM(elem, side);
 
  auto n = numExtraElemIntegers();
  for (auto i : make_range(n))
    _extra_elem_ids[i] = _current_elem->get_extra_integer(i);
  _extra_elem_ids[n] = _current_elem->subdomain_id();
}

Referenced by reinit(), and reinit().

reinitFEFaceNeighbor()

void Assembly::reinitFEFaceNeighbor ( const Elem *  neighbor, const std::vector< Point > &  reference_points  )

private

Definition at line 1612 of file Assembly.C.

{
  unsigned int neighbor_dim = neighbor->dim();
 
  // reinit neighbor face
  for (const auto & it : _fe_face_neighbor[neighbor_dim])
  {
    FEBase & fe_face_neighbor = *it.second;
    FEType fe_type = it.first;
    FEShapeData & fesd = *_fe_shape_data_face_neighbor[fe_type];
 
    fe_face_neighbor.reinit(neighbor, &reference_points);
 
    _current_fe_face_neighbor[fe_type] = &fe_face_neighbor;
 
    fesd._phi.shallowCopy(const_cast<std::vector<std::vector<Real>> &>(fe_face_neighbor.get_phi()));
    fesd._grad_phi.shallowCopy(
        const_cast<std::vector<std::vector<RealGradient>> &>(fe_face_neighbor.get_dphi()));
    if (_need_second_derivative_neighbor.count(fe_type))
      fesd._second_phi.shallowCopy(
          const_cast<std::vector<std::vector<TensorValue<Real>>> &>(fe_face_neighbor.get_d2phi()));
  }
  for (const auto & it : _vector_fe_face_neighbor[neighbor_dim])
  {
    FEVectorBase & fe_face_neighbor = *it.second;
    const FEType & fe_type = it.first;
 
    _current_vector_fe_face_neighbor[fe_type] = &fe_face_neighbor;
 
    VectorFEShapeData & fesd = *_vector_fe_shape_data_face_neighbor[fe_type];
 
    fe_face_neighbor.reinit(neighbor, &reference_points);
 
    fesd._phi.shallowCopy(
        const_cast<std::vector<std::vector<VectorValue<Real>>> &>(fe_face_neighbor.get_phi()));
    fesd._grad_phi.shallowCopy(
        const_cast<std::vector<std::vector<TensorValue<Real>>> &>(fe_face_neighbor.get_dphi()));
    if (_need_second_derivative.count(fe_type))
      fesd._second_phi.shallowCopy(const_cast<std::vector<std::vector<TypeNTensor<3, Real>>> &>(
          fe_face_neighbor.get_d2phi()));
    if (_need_curl.count(fe_type))
      fesd._curl_phi.shallowCopy(const_cast<std::vector<std::vector<VectorValue<Real>>> &>(
          fe_face_neighbor.get_curl_phi()));
    if (_need_face_neighbor_div.count(fe_type))
      fesd._div_phi.shallowCopy(
          const_cast<std::vector<std::vector<Real>> &>(fe_face_neighbor.get_div_phi()));
  }
  if (!_unique_fe_face_neighbor_helper.empty())
  {
    mooseAssert(neighbor_dim < _unique_fe_face_neighbor_helper.size(),
                "We should be in bounds here");
    _unique_fe_face_neighbor_helper[neighbor_dim]->reinit(neighbor, &reference_points);
  }
 
  _current_q_points_face_neighbor.shallowCopy(
      const_cast<std::vector<Point> &>(_holder_fe_face_neighbor_helper[neighbor_dim]->get_xyz()));
}

Referenced by reinitElemAndNeighbor(), and reinitNeighborAtPhysical().

reinitFENeighbor()

void Assembly::reinitFENeighbor ( const Elem *  neighbor, const std::vector< Point > &  reference_points  )

private

Definition at line 1671 of file Assembly.C.

{
  unsigned int neighbor_dim = neighbor->dim();
 
  // reinit neighbor face
  for (const auto & it : _fe_neighbor[neighbor_dim])
  {
    FEBase & fe_neighbor = *it.second;
    FEType fe_type = it.first;
    FEShapeData & fesd = *_fe_shape_data_neighbor[fe_type];
 
    fe_neighbor.reinit(neighbor, &reference_points);
 
    _current_fe_neighbor[fe_type] = &fe_neighbor;
 
    fesd._phi.shallowCopy(const_cast<std::vector<std::vector<Real>> &>(fe_neighbor.get_phi()));
    fesd._grad_phi.shallowCopy(
        const_cast<std::vector<std::vector<RealGradient>> &>(fe_neighbor.get_dphi()));
    if (_need_second_derivative_neighbor.count(fe_type))
      fesd._second_phi.shallowCopy(
          const_cast<std::vector<std::vector<TensorValue<Real>>> &>(fe_neighbor.get_d2phi()));
  }
  for (const auto & it : _vector_fe_neighbor[neighbor_dim])
  {
    FEVectorBase & fe_neighbor = *it.second;
    const FEType & fe_type = it.first;
 
    _current_vector_fe_neighbor[fe_type] = &fe_neighbor;
 
    VectorFEShapeData & fesd = *_vector_fe_shape_data_neighbor[fe_type];
 
    fe_neighbor.reinit(neighbor, &reference_points);
 
    fesd._phi.shallowCopy(
        const_cast<std::vector<std::vector<VectorValue<Real>>> &>(fe_neighbor.get_phi()));
    fesd._grad_phi.shallowCopy(
        const_cast<std::vector<std::vector<TensorValue<Real>>> &>(fe_neighbor.get_dphi()));
    if (_need_second_derivative.count(fe_type))
      fesd._second_phi.shallowCopy(
          const_cast<std::vector<std::vector<TypeNTensor<3, Real>>> &>(fe_neighbor.get_d2phi()));
    if (_need_curl.count(fe_type))
      fesd._curl_phi.shallowCopy(
          const_cast<std::vector<std::vector<VectorValue<Real>>> &>(fe_neighbor.get_curl_phi()));
    if (_need_neighbor_div.count(fe_type))
      fesd._div_phi.shallowCopy(
          const_cast<std::vector<std::vector<Real>> &>(fe_neighbor.get_div_phi()));
  }
  if (!_unique_fe_neighbor_helper.empty())
  {
    mooseAssert(neighbor_dim < _unique_fe_neighbor_helper.size(), "We should be in bounds here");
    _unique_fe_neighbor_helper[neighbor_dim]->reinit(neighbor, &reference_points);
  }
}

Referenced by reinitNeighborAtPhysical().

reinitFVFace()

void Assembly::reinitFVFace

(

const FaceInfo &

fi

)

Definition at line 1896 of file Assembly.C.

{
  _current_elem = &fi.elem();
  _current_neighbor_elem = fi.neighborPtr();
  _current_side = fi.elemSideID();
  _current_neighbor_side = fi.neighborSideID();
  mooseAssert(_current_subdomain_id == _current_elem->subdomain_id(),
              "current subdomain has been set incorrectly");
 
  _current_elem_volume_computed = false;
  _current_side_volume_computed = false;
 
  prepareResidual();
  prepareNeighbor();
  prepareJacobianBlock();
 
  unsigned int dim = _current_elem->dim();
  if (_current_qrule_face != qrules(dim).fv_face.get())
  {
    setFaceQRule(qrules(dim).fv_face.get(), dim);
    // The order of the element that is used for initing here doesn't matter since this will just
    // be used for constant monomials (which only need a single integration point)
    if (dim == 3)
      _current_qrule_face->init(QUAD4, /* p_level = */ 0, /* simple_type_only = */ true);
    else
      _current_qrule_face->init(EDGE2, /* p_level = */ 0, /* simple_type_only = */ true);
  }
 
  _current_side_elem = &_current_side_elem_builder(*_current_elem, _current_side);
 
  mooseAssert(_current_qrule_face->n_points() == 1,
              "Our finite volume quadrature rule should always yield a single point");
 
  // We've initialized the reference points. Now we need to compute the physical location of the
  // quadrature points. We do not do any FE initialization so we cannot simply copy over FE
  // results like we do in reinitFEFace. Instead we handle the computation of the physical
  // locations manually
  _current_q_points_face.resize(1);
  const auto & ref_points = _current_qrule_face->get_points();
  const auto & ref_point = ref_points[0];
  auto physical_point = FEMap::map(_current_side_elem->dim(), _current_side_elem, ref_point);
  _current_q_points_face[0] = physical_point;
 
  if (_current_neighbor_elem)
  {
    mooseAssert(_current_neighbor_subdomain_id == _current_neighbor_elem->subdomain_id(),
                "current neighbor subdomain has been set incorrectly");
    // Now handle the neighbor qrule/qpoints
    ArbitraryQuadrature * const neighbor_rule =
        qrules(_current_neighbor_elem->dim(), _current_neighbor_subdomain_id).neighbor.get();
    // Here we are setting a reference point that is correct for the neighbor *side* element. It
    // would be wrong if this reference point is used for a volumetric FE reinit with the neighbor
    neighbor_rule->setPoints(ref_points);
    setNeighborQRule(neighbor_rule, _current_neighbor_elem->dim());
    _current_q_points_face_neighbor.resize(1);
    _current_q_points_face_neighbor[0] = std::move(physical_point);
  }
}

Referenced by SubProblem::reinitFVFace().

reinitLowerDElem()

void Assembly::reinitLowerDElem	(	const Elem *	elem,
		const std::vector< Point > *const	pts = nullptr,
		const std::vector< Real > *const	weights = nullptr
	)

Reinitialize FE data for a lower dimenesional element with a given set of reference points.

Definition at line 2344 of file Assembly.C.

{
  _current_lower_d_elem = elem;
 
  const unsigned int elem_dim = elem->dim();
  mooseAssert(elem_dim < _mesh_dimension,
              "The lower dimensional element should truly be a lower dimensional element");
 
  if (pts)
  {
    // Lower rule matches the face rule for the higher dimensional element
    ArbitraryQuadrature * lower_rule = qrules(elem_dim + 1).arbitrary_face.get();
 
    // This also sets the quadrature weights to unity
    lower_rule->setPoints(*pts);
 
    if (weights)
      lower_rule->setWeights(*weights);
 
    setLowerQRule(lower_rule, elem_dim);
  }
  else if (_current_qrule_lower != qrules(elem_dim + 1).face.get())
    setLowerQRule(qrules(elem_dim + 1).face.get(), elem_dim);
 
  for (const auto & it : _fe_lower[elem_dim])
  {
    FEBase & fe_lower = *it.second;
    FEType fe_type = it.first;
 
    fe_lower.reinit(elem);
 
    if (FEShapeData * fesd = _fe_shape_data_lower[fe_type].get())
    {
      fesd->_phi.shallowCopy(const_cast<std::vector<std::vector<Real>> &>(fe_lower.get_phi()));
      fesd->_grad_phi.shallowCopy(
          const_cast<std::vector<std::vector<RealGradient>> &>(fe_lower.get_dphi()));
      if (_need_second_derivative_neighbor.count(fe_type))
        fesd->_second_phi.shallowCopy(
            const_cast<std::vector<std::vector<TensorValue<Real>>> &>(fe_lower.get_d2phi()));
    }
 
    // Dual shape functions need to be computed after primal basis being initialized
    if (FEShapeData * fesd = _fe_shape_data_dual_lower[fe_type].get())
    {
      fesd->_phi.shallowCopy(const_cast<std::vector<std::vector<Real>> &>(fe_lower.get_dual_phi()));
      fesd->_grad_phi.shallowCopy(
          const_cast<std::vector<std::vector<RealGradient>> &>(fe_lower.get_dual_dphi()));
      if (_need_second_derivative_neighbor.count(fe_type))
        fesd->_second_phi.shallowCopy(
            const_cast<std::vector<std::vector<TensorValue<Real>>> &>(fe_lower.get_dual_d2phi()));
    }
  }
  if (!_unique_fe_lower_helper.empty())
  {
    mooseAssert(elem_dim < _unique_fe_lower_helper.size(), "We should be in bounds here");
    _unique_fe_lower_helper[elem_dim]->reinit(elem);
  }
 
  if (!_need_lower_d_elem_volume)
    return;
 
  if (pts && !weights)
  {
    // We only have dummy weights so the JxWs computed during our FE reinits are meaningless and
    // we cannot use them
 
    if (_subproblem.getCoordSystem(elem->subdomain_id()) == Moose::CoordinateSystemType::COORD_XYZ)
      // We are in a Cartesian coordinate system and we can just use the element volume method
      // which has fast computation for certain element types
      _current_lower_d_elem_volume = elem->volume();
    else
      // We manually compute the volume taking the curvilinear coordinate transformations into
      // account
      _current_lower_d_elem_volume = elementVolume(elem);
  }
  else
  {
    // During that last loop the helper objects will have been reinitialized as well
    FEBase & helper_fe = *_holder_fe_lower_helper[elem_dim];
    const auto & physical_q_points = helper_fe.get_xyz();
    const auto & JxW = helper_fe.get_JxW();
    MooseArray<Real> coord;
    setCoordinateTransformation(
        _current_qrule_lower, physical_q_points, coord, elem->subdomain_id());
    _current_lower_d_elem_volume = 0;
    for (const auto qp : make_range(_current_qrule_lower->n_points()))
      _current_lower_d_elem_volume += JxW[qp] * coord[qp];
  }
}

Referenced by SubProblem::reinitLowerDElem().

reinitMortarElem()

void Assembly::reinitMortarElem

(

const Elem *

elem

)

reinitialize a mortar segment mesh element in order to get a proper JxW

Definition at line 2458 of file Assembly.C.

{
  mooseAssert(elem->dim() == _mesh_dimension - 1,
              "You should be calling reinitMortarElem on a lower dimensional element");
 
  _fe_msm->reinit(elem);
  _msm_elem = elem;
 
  MooseArray<Point> array_q_points;
  array_q_points.shallowCopy(const_cast<std::vector<Point> &>(_fe_msm->get_xyz()));
  setCoordinateTransformation(_qrule_msm, array_q_points, _coord_msm, elem->subdomain_id());
}

Referenced by SubProblem::reinitMortarElem().

reinitNeighbor()

void Assembly::reinitNeighbor	(	const Elem *	neighbor,
		const std::vector< Point > &	reference_points
	)

Reinitializes the neighbor side using reference coordinates.

Definition at line 1726 of file Assembly.C.

{
  unsigned int neighbor_dim = neighbor->dim();
  mooseAssert(_current_neighbor_subdomain_id == neighbor->subdomain_id(),
              "Neighbor subdomain ID has not been correctly set");
 
  ArbitraryQuadrature * neighbor_rule =
      qrules(neighbor_dim, _current_neighbor_subdomain_id).neighbor.get();
  neighbor_rule->setPoints(reference_points);
  setNeighborQRule(neighbor_rule, neighbor_dim);
 
  _current_neighbor_elem = neighbor;
  mooseAssert(_current_neighbor_subdomain_id == _current_neighbor_elem->subdomain_id(),
              "current neighbor subdomain has been set incorrectly");
 
  // Calculate the volume of the neighbor
  if (_need_neighbor_elem_volume)
  {
    unsigned int dim = neighbor->dim();
    FEBase & fe = *_holder_fe_neighbor_helper[dim];
    QBase * qrule = qrules(dim).vol.get();
 
    fe.attach_quadrature_rule(qrule);
    fe.reinit(neighbor);
 
    const std::vector<Real> & JxW = fe.get_JxW();
    MooseArray<Point> q_points;
    q_points.shallowCopy(const_cast<std::vector<Point> &>(fe.get_xyz()));
 
    setCoordinateTransformation(qrule, q_points, _coord_neighbor, _current_neighbor_subdomain_id);
 
    _current_neighbor_volume = 0.;
    for (unsigned int qp = 0; qp < qrule->n_points(); qp++)
      _current_neighbor_volume += JxW[qp] * _coord_neighbor[qp];
  }
 
  auto n = numExtraElemIntegers();
  for (auto i : make_range(n))
    _neighbor_extra_elem_ids[i] = _current_neighbor_elem->get_extra_integer(i);
  _neighbor_extra_elem_ids[n] = _current_neighbor_elem->subdomain_id();
}

Referenced by reinitElemAndNeighbor(), reinitNeighborAtPhysical(), and reinitNeighborAtPhysical().

reinitNeighborAtPhysical() [1/2]

void Assembly::reinitNeighborAtPhysical	(	const Elem *	neighbor,
		const std::vector< Point > &	physical_points
	)

Reinitializes the neighbor at the physical coordinates within element given.

Definition at line 2508 of file Assembly.C.

{
  unsigned int neighbor_dim = neighbor->dim();
  FEMap::inverse_map(neighbor_dim, neighbor, physical_points, _current_neighbor_ref_points);
 
  reinitFENeighbor(neighbor, _current_neighbor_ref_points);
  reinitNeighbor(neighbor, _current_neighbor_ref_points);
  // Save off the physical points
  _current_physical_points = physical_points;
}

reinitNeighborAtPhysical() [2/2]

void Assembly::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.

Definition at line 2472 of file Assembly.C.

{
  unsigned int neighbor_dim = neighbor->dim();
  FEMap::inverse_map(neighbor_dim, neighbor, physical_points, _current_neighbor_ref_points);
 
  if (_need_JxW_neighbor)
  {
    mooseAssert(
        physical_points.size() == 1,
        "If reinitializing with more than one point, then I am dubious of your use case. Perhaps "
        "you are performing a DG type method and you are reinitializing using points from the "
        "element face. In such a case your neighbor JxW must have its index order 'match' the "
        "element JxW index order, e.g. imagining a vertical 1D face with two quadrature points, "
        "if "
        "index 0 for elem JxW corresponds to the 'top' quadrature point, then index 0 for "
        "neighbor "
        "JxW must also correspond to the 'top' quadrature point. And libMesh/MOOSE has no way to "
        "guarantee that with multiple quadrature points.");
 
    _current_neighbor_side_elem = &_current_neighbor_side_elem_builder(*neighbor, neighbor_side);
 
    // With a single point our size-1 JxW should just be the element volume
    _current_JxW_neighbor.resize(1);
    _current_JxW_neighbor[0] = _current_neighbor_side_elem->volume();
  }
 
  reinitFEFaceNeighbor(neighbor, _current_neighbor_ref_points);
  reinitNeighbor(neighbor, _current_neighbor_ref_points);
 
  // Save off the physical points
  _current_physical_points = physical_points;
}

reinitNeighborFaceRef()

void Assembly::reinitNeighborFaceRef	(	const Elem *	neighbor_elem,
		unsigned int	neighbor_side,
		Real	tolerance,
		const std::vector< Point > *const	pts,
		const std::vector< Real > *const	weights = nullptr
	)

Reinitialize FE data for the given neighbor_element on the given side with a given set of reference points.

Definition at line 2245 of file Assembly.C.

{
  _current_neighbor_elem = neighbor;
 
  unsigned int neighbor_dim = neighbor->dim();
 
  ArbitraryQuadrature * neighbor_rule =
      qrules(neighbor_dim, neighbor->subdomain_id()).neighbor.get();
  neighbor_rule->setPoints(*pts);
 
  // Attach this quadrature rule to all the _fe_face_neighbor FE objects. This
  // has to have garbage quadrature weights but that's ok because we never
  // actually use the JxW coming from these FE reinit'd objects, e.g. we use the
  // JxW coming from the element face reinit for DGKernels or we use the JxW
  // coming from reinit of the mortar segment element in the case of mortar
  setNeighborQRule(neighbor_rule, neighbor_dim);
 
  // reinit neighbor face
  for (const auto & it : _fe_face_neighbor[neighbor_dim])
  {
    FEBase & fe_face_neighbor = *it.second;
    FEType fe_type = it.first;
    FEShapeData & fesd = *_fe_shape_data_face_neighbor[fe_type];
 
    fe_face_neighbor.reinit(neighbor, neighbor_side, tolerance, pts, weights);
 
    _current_fe_face_neighbor[fe_type] = &fe_face_neighbor;
 
    fesd._phi.shallowCopy(const_cast<std::vector<std::vector<Real>> &>(fe_face_neighbor.get_phi()));
    fesd._grad_phi.shallowCopy(
        const_cast<std::vector<std::vector<RealGradient>> &>(fe_face_neighbor.get_dphi()));
    if (_need_second_derivative_neighbor.count(fe_type))
      fesd._second_phi.shallowCopy(
          const_cast<std::vector<std::vector<TensorValue<Real>>> &>(fe_face_neighbor.get_d2phi()));
  }
  for (const auto & it : _vector_fe_face_neighbor[neighbor_dim])
  {
    FEVectorBase & fe_face_neighbor = *it.second;
    const FEType & fe_type = it.first;
 
    _current_vector_fe_face_neighbor[fe_type] = &fe_face_neighbor;
 
    VectorFEShapeData & fesd = *_vector_fe_shape_data_face_neighbor[fe_type];
 
    fe_face_neighbor.reinit(neighbor, neighbor_side, tolerance, pts, weights);
 
    fesd._phi.shallowCopy(
        const_cast<std::vector<std::vector<VectorValue<Real>>> &>(fe_face_neighbor.get_phi()));
    fesd._grad_phi.shallowCopy(
        const_cast<std::vector<std::vector<TensorValue<Real>>> &>(fe_face_neighbor.get_dphi()));
    if (_need_second_derivative.count(fe_type))
      fesd._second_phi.shallowCopy(const_cast<std::vector<std::vector<TypeNTensor<3, Real>>> &>(
          fe_face_neighbor.get_d2phi()));
    if (_need_curl.count(fe_type))
      fesd._curl_phi.shallowCopy(const_cast<std::vector<std::vector<VectorValue<Real>>> &>(
          fe_face_neighbor.get_curl_phi()));
    if (_need_face_neighbor_div.count(fe_type))
      fesd._div_phi.shallowCopy(
          const_cast<std::vector<std::vector<Real>> &>(fe_face_neighbor.get_div_phi()));
  }
  if (!_unique_fe_face_neighbor_helper.empty())
  {
    mooseAssert(neighbor_dim < _unique_fe_face_neighbor_helper.size(),
                "We should be in bounds here");
    _unique_fe_face_neighbor_helper[neighbor_dim]->reinit(
        neighbor, neighbor_side, tolerance, pts, weights);
  }
  // During that last loop the helper objects will have been reinitialized as well
  // We need to dig out the q_points from it
  _current_q_points_face_neighbor.shallowCopy(
      const_cast<std::vector<Point> &>(_holder_fe_face_neighbor_helper[neighbor_dim]->get_xyz()));
}

Referenced by SubProblem::reinitNeighborFaceRef().

reinitNeighborLowerDElem()

void Assembly::reinitNeighborLowerDElem

(

const Elem *

elem

)

reinitialize a neighboring lower dimensional element

Definition at line 2437 of file Assembly.C.

{
  mooseAssert(elem->dim() < _mesh_dimension,
              "You should be calling reinitNeighborLowerDElem on a lower dimensional element");
 
  _current_neighbor_lower_d_elem = elem;
 
  if (!_need_neighbor_lower_d_elem_volume)
    return;
 
  if (_subproblem.getCoordSystem(elem->subdomain_id()) == Moose::CoordinateSystemType::COORD_XYZ)
    // We are in a Cartesian coordinate system and we can just use the element volume method which
    // has fast computation for certain element types
    _current_neighbor_lower_d_elem_volume = elem->volume();
  else
    // We manually compute the volume taking the curvilinear coordinate transformations into
    // account
    _current_neighbor_lower_d_elem_volume = elementVolume(elem);
}

Referenced by SubProblem::reinitNeighborLowerDElem().

residualBlock()

DenseVector< Number > & Assembly::residualBlock ( unsigned int  var_num, LocalDataKey  , TagID  tag_id  )

inline

Get local residual block for a variable and a tag.

Only blessed framework classes may call this API by creating the requisiste LocalDataKey class

Definition at line 1107 of file Assembly.h.

  {
    return _sub_Re[tag_id][var_num];
  }

Referenced by TaggingInterface::prepareVectorTagInternal().

residualBlockLower()

DenseVector< Number > & Assembly::residualBlockLower ( unsigned int  var_num, LocalDataKey  , TagID  tag_id  )

inline

Get residual block for lower.

Only blessed framework classes may call this API by creating the requisiste LocalDataKey class

Definition at line 1125 of file Assembly.h.

  {
    return _sub_Rl[tag_id][var_num];
  }

Referenced by TaggingInterface::prepareVectorTagLower().

residualBlockNeighbor()

DenseVector< Number > & Assembly::residualBlockNeighbor ( unsigned int  var_num, LocalDataKey  , TagID  tag_id  )

inline

Get local neighbor residual block for a variable and a tag.

Only blessed framework classes may call this API by creating the requisiste LocalDataKey class

Definition at line 1116 of file Assembly.h.

  {
    return _sub_Rn[tag_id][var_num];
  }

Referenced by TaggingInterface::prepareVectorTagNeighbor().

resizeADMappingObjects()

void Assembly::resizeADMappingObjects ( unsigned int  n_qp, unsigned int  dim  )

private

resize any objects that contribute to automatic differentiation-related mapping calculations

Definition at line 1008 of file Assembly.C.

{
  _ad_dxyzdxi_map.resize(n_qp);
  _ad_dxidx_map.resize(n_qp);
  _ad_dxidy_map.resize(n_qp); // 1D element may live in 2D ...
  _ad_dxidz_map.resize(n_qp); // ... or 3D
 
  if (dim > 1)
  {
    _ad_dxyzdeta_map.resize(n_qp);
    _ad_detadx_map.resize(n_qp);
    _ad_detady_map.resize(n_qp);
    _ad_detadz_map.resize(n_qp);
 
    if (dim > 2)
    {
      _ad_dxyzdzeta_map.resize(n_qp);
      _ad_dzetadx_map.resize(n_qp);
      _ad_dzetady_map.resize(n_qp);
      _ad_dzetadz_map.resize(n_qp);
    }
  }
 
  _ad_jac.resize(n_qp);
  _ad_JxW.resize(n_qp);
  if (_calculate_xyz)
    _ad_q_points.resize(n_qp);
}

Referenced by computeADFace(), and reinitFE().

saveDiagLocalArrayJacobian()

void Assembly::saveDiagLocalArrayJacobian ( DenseMatrix< Number > &  ke, unsigned int  i, unsigned int  ntest, unsigned int  j, unsigned int  nphi, unsigned int  ivar, const RealEigenVector &  v  ) const

inline

Helper function for assembling diagonal Jacobian contriubutions on local quadrature points for an array kernel, bc, etc.

Parameters

ke	The local Jacobian
i	The local test function index
ntest	The number of test functions
j	The local shape function index
nphi	The number of shape functions
v	The diagonal Jacobian contribution on the current qp

Definition at line 1839 of file Assembly.h.

  {
    unsigned int pace = (_component_block_diagonal[ivar] ? 0 : nphi);
    for (unsigned int k = 0; k < v.size(); ++k, i += ntest, j += pace)
      ke(i, j) += v(k);
  }

Referenced by ArrayDGKernel::computeElemNeighJacobian(), ArrayIntegratedBC::computeJacobian(), ArrayKernel::computeJacobian(), ArrayDGLowerDKernel::computeLowerDJacobian(), and ArrayLowerDIntegratedBC::computeLowerDJacobian().

saveFullLocalArrayJacobian()

void Assembly::saveFullLocalArrayJacobian ( DenseMatrix< Number > &  ke, unsigned int  i, unsigned int  ntest, unsigned int  j, unsigned int  nphi, unsigned int  ivar, unsigned int  jvar, const RealEigenMatrix &  v  ) const

inline

Helper function for assembling full Jacobian contriubutions on local quadrature points for an array kernel, bc, etc.

Parameters

ke	The local Jacobian
i	The local test function index
ntest	The number of test functions
j	The local shape function index
nphi	The number of shape functions
ivar	The array variable index
jvar	The contributing variable index
v	The full Jacobian contribution from a variable on the current qp

Definition at line 1864 of file Assembly.h.

  {
    if (ivar == jvar && _component_block_diagonal[ivar])
    {
      for (unsigned int k = 0; k < v.rows(); ++k, i += ntest)
        ke(i, j) += v(k, k);
    }
    else
    {
      const unsigned int saved_j = j;
      for (unsigned int k = 0; k < v.rows(); ++k, i += ntest)
      {
        j = saved_j;
        for (unsigned int l = 0; l < v.cols(); ++l, j += nphi)
          ke(i, j) += v(k, l);
      }
    }
  }

Referenced by ArrayLowerDIntegratedBC::computeLowerDOffDiagJacobian(), ArrayDGKernel::computeOffDiagElemNeighJacobian(), ArrayIntegratedBC::computeOffDiagJacobian(), ArrayKernel::computeOffDiagJacobian(), ArrayIntegratedBC::computeOffDiagJacobianScalar(), ArrayKernel::computeOffDiagJacobianScalar(), and ArrayDGLowerDKernel::computeOffDiagLowerDJacobian().

saveLocalADArray()

void Assembly::saveLocalADArray	(	std::vector< ADReal > &	re,
		unsigned int	i,
		unsigned int	ntest,
		const ADRealEigenVector &	v
	)		const

Definition at line 3842 of file Assembly.C.

{
  for (unsigned int j = 0; j < v.size(); ++j, i += ntest)
    re[i] += v(j);
}

Referenced by ADArrayKernel::computeJacobian().

saveLocalArrayResidual()

void Assembly::saveLocalArrayResidual ( DenseVector< Number > &  re, unsigned int  i, unsigned int  ntest, const RealEigenVector &  v  ) const

inline

Helper function for assembling residual contriubutions on local quadrature points for an array kernel, bc, etc.

Parameters

re	The local residual
i	The local test function index
ntest	The number of test functions
v	The residual contribution on the current qp

Definition at line 1815 of file Assembly.h.

  {
    for (unsigned int j = 0; j < v.size(); ++j, i += ntest)
      re(i) += v(j);
  }

Referenced by ArrayDGKernel::computeElemNeighResidual(), ArrayDGLowerDKernel::computeLowerDResidual(), ArrayIntegratedBC::computeResidual(), ArrayLowerDIntegratedBC::computeResidual(), ADArrayKernel::computeResidual(), and ArrayKernel::computeResidual().

scalarFieldCouplingEntries()

const std::vector< std::pair< MooseVariableScalar *, MooseVariableFieldBase * > > & Assembly::scalarFieldCouplingEntries ( ) const

inline

Definition at line 1306 of file Assembly.h.

  {
    return _cm_sf_entry;
  }

Referenced by MortarScalarBase::computeScalarOffDiagJacobian().

secondPhi() [1/6]

const VariablePhiSecond & Assembly::secondPhi ( ) const

inline

Definition at line 1321 of file Assembly.h.

{ return _second_phi; }

Referenced by copyShapes().

secondPhi() [2/6]

VariablePhiSecond & Assembly::secondPhi ( const MooseVariableField< Real > &  )

inline

Definition at line 1459 of file Assembly.h.

{ return _second_phi; }

secondPhi() [3/6]

const VariablePhiSecond & Assembly::secondPhi ( const MooseVariableField< Real > &  ) const

inline

Definition at line 1322 of file Assembly.h.

  {
    return _second_phi;
  }

secondPhi() [4/6]

VariablePhiSecond & Assembly::secondPhi ( const MooseVariableField< RealEigenVector > &  )

inline

Definition at line 1572 of file Assembly.h.

{ return _second_phi; }

secondPhi() [5/6]

VectorVariablePhiSecond & Assembly::secondPhi ( const MooseVariableField< RealVectorValue > &  )

inline

Definition at line 1494 of file Assembly.h.

  {
    return _vector_second_phi;
  }

secondPhi() [6/6]

const VectorVariablePhiSecond & Assembly::secondPhi ( const MooseVariableField< RealVectorValue > &  ) const

inline

Definition at line 1373 of file Assembly.h.

  {
    return _vector_second_phi;
  }

secondPhiFace() [1/5]

VariablePhiSecond & Assembly::secondPhiFace ( const MooseVariableField< Real > &  )

inline

Definition at line 1463 of file Assembly.h.

{ return _second_phi_face; }

secondPhiFace() [2/5]

const VariablePhiSecond & Assembly::secondPhiFace ( const MooseVariableField< Real > &  ) const

inline

Definition at line 1334 of file Assembly.h.

  {
    return _second_phi_face;
  }

Referenced by copyFaceShapes().

secondPhiFace() [3/5]

VariablePhiSecond & Assembly::secondPhiFace ( const MooseVariableField< RealEigenVector > &  )

inline

Definition at line 1579 of file Assembly.h.

  {
    return _second_phi_face;
  }

secondPhiFace() [4/5]

VectorVariablePhiSecond & Assembly::secondPhiFace ( const MooseVariableField< RealVectorValue > &  )

inline

Definition at line 1515 of file Assembly.h.

  {
    return _vector_second_phi_face;
  }

secondPhiFace() [5/5]

const VectorVariablePhiSecond & Assembly::secondPhiFace ( const MooseVariableField< RealVectorValue > &  ) const

inline

Definition at line 1394 of file Assembly.h.

  {
    return _vector_second_phi_face;
  }

secondPhiFaceNeighbor() [1/5]

VariablePhiSecond & Assembly::secondPhiFaceNeighbor ( const MooseVariableField< Real > &  )

inline

Definition at line 1483 of file Assembly.h.

  {
    return _second_phi_face_neighbor;
  }

secondPhiFaceNeighbor() [2/5]

const VariablePhiSecond & Assembly::secondPhiFaceNeighbor ( const MooseVariableField< Real > &  ) const

inline

Definition at line 1360 of file Assembly.h.

  {
    return _second_phi_face_neighbor;
  }

Referenced by copyNeighborShapes().

secondPhiFaceNeighbor() [3/5]

VariablePhiSecond & Assembly::secondPhiFaceNeighbor ( const MooseVariableField< RealEigenVector > &  )

inline

Definition at line 1605 of file Assembly.h.

  {
    return _second_phi_face_neighbor;
  }

secondPhiFaceNeighbor() [4/5]

VectorVariablePhiSecond & Assembly::secondPhiFaceNeighbor ( const MooseVariableField< RealVectorValue > &  )

inline

Definition at line 1556 of file Assembly.h.

  {
    return _vector_second_phi_face_neighbor;
  }

secondPhiFaceNeighbor() [5/5]

const VectorVariablePhiSecond & Assembly::secondPhiFaceNeighbor ( const MooseVariableField< RealVectorValue > &  ) const

inline

Definition at line 1441 of file Assembly.h.

  {
    return _vector_second_phi_face_neighbor;
  }

secondPhiNeighbor() [1/5]

VariablePhiSecond & Assembly::secondPhiNeighbor ( const MooseVariableField< Real > &  )

inline

Definition at line 1470 of file Assembly.h.

  {
    return _second_phi_neighbor;
  }

secondPhiNeighbor() [2/5]

const VariablePhiSecond & Assembly::secondPhiNeighbor ( const MooseVariableField< Real > &  ) const

inline

Definition at line 1347 of file Assembly.h.

  {
    return _second_phi_neighbor;
  }

Referenced by copyNeighborShapes().

secondPhiNeighbor() [3/5]

VariablePhiSecond & Assembly::secondPhiNeighbor ( const MooseVariableField< RealEigenVector > &  )

inline

Definition at line 1592 of file Assembly.h.

  {
    return _second_phi_neighbor;
  }

secondPhiNeighbor() [4/5]

VectorVariablePhiSecond & Assembly::secondPhiNeighbor ( const MooseVariableField< RealVectorValue > &  )

inline

Definition at line 1536 of file Assembly.h.

  {
    return _vector_second_phi_neighbor;
  }

secondPhiNeighbor() [5/5]

const VectorVariablePhiSecond & Assembly::secondPhiNeighbor ( const MooseVariableField< RealVectorValue > &  ) const

inline

Definition at line 1417 of file Assembly.h.

  {
    return _vector_second_phi_neighbor;
  }

setCachedJacobian()

void Assembly::setCachedJacobian

(

GlobalDataKey

)

Sets previously-cached Jacobian values via SparseMatrix::set() calls.

Definition at line 4528 of file Assembly.C.

{
  for (MooseIndex(_cached_jacobian_rows) tag = 0; tag < _cached_jacobian_rows.size(); tag++)
    if (_sys.hasMatrix(tag))
    {
      // First zero the rows (including the diagonals) to prepare for
      // setting the cached values.
      _sys.getMatrix(tag).zero_rows(_cached_jacobian_rows[tag], 0.0);
 
      // TODO: Use SparseMatrix::set_values() for efficiency
      for (MooseIndex(_cached_jacobian_values) i = 0; i < _cached_jacobian_values[tag].size(); ++i)
        _sys.getMatrix(tag).set(_cached_jacobian_rows[tag][i],
                                _cached_jacobian_cols[tag][i],
                                _cached_jacobian_values[tag][i]);
    }
 
  clearCachedJacobian();
}

setCoordinateTransformation() [1/2]

template<typename Points , typename Coords >

void Assembly::setCoordinateTransformation ( const libMesh::QBase *  qrule, const Points &  q_points, Coords &  coord, SubdomainID  sub_id  )

private

Referenced by computeCurrentElemVolume(), computeCurrentFaceVolume(), reinitLowerDElem(), reinitMortarElem(), and reinitNeighbor().

setCoordinateTransformation() [2/2]

template<typename Points , typename Coords >

void Assembly::setCoordinateTransformation	(	const QBase *	qrule,
		const Points &	q_points,
		Coords &	coord,
		SubdomainID	sub_id
	)

Definition at line 1770 of file Assembly.C.

{
 
  mooseAssert(qrule, "The quadrature rule is null in Assembly::setCoordinateTransformation");
  auto n_points = qrule->n_points();
  mooseAssert(n_points == q_points.size(),
              "The number of points in the quadrature rule doesn't match the number of passed-in "
              "points in Assembly::setCoordinateTransformation");
 
  // Make sure to honor the name of this method and set the _coord_type member because users may
  // make use of the const Moose::CoordinateSystem & coordTransformation() { return _coord_type; }
  // API. MaterialBase for example uses it
  _coord_type = _subproblem.getCoordSystem(sub_id);
 
  coord.resize(n_points);
  for (unsigned int qp = 0; qp < n_points; qp++)
    coordTransformFactor(_subproblem, sub_id, q_points[qp], coord[qp]);
}

setCurrentBoundaryID()

void Assembly::setCurrentBoundaryID ( BoundaryID  i )

inline

set the current boundary ID

Definition at line 426 of file Assembly.h.

{ _current_boundary_id = i; }

Referenced by SubProblem::setCurrentBoundaryID().

setCurrentLowerDElem()

void Assembly::setCurrentLowerDElem ( const Elem *const  lower_d_elem )

inline

Set the current lower dimensional element.

This may be null

Definition at line 3225 of file Assembly.h.

{
  _current_lower_d_elem = lower_d_elem;
}

Referenced by SubProblem::setCurrentLowerDElem().

setCurrentNeighborSubdomainID()

void Assembly::setCurrentNeighborSubdomainID ( SubdomainID  i )

inline

set the current subdomain ID

Definition at line 494 of file Assembly.h.

{ _current_neighbor_subdomain_id = i; }

Referenced by DisplacedProblem::setNeighborSubdomainID().

setCurrentSubdomainID()

void Assembly::setCurrentSubdomainID ( SubdomainID  i )

inline

set the current subdomain ID

Definition at line 416 of file Assembly.h.

{ _current_subdomain_id = i; }

Referenced by MooseMesh::buildHRefinementAndCoarseningMaps(), MooseMesh::buildPRefinementAndCoarseningMaps(), MaxQpsThread::operator()(), and DisplacedProblem::setCurrentSubdomainID().

setFaceQRule() [1/2]

void Assembly::setFaceQRule	(	const Elem *const	elem,
		const unsigned int	side
	)

Set the face quadrature rule based on the provided element and side.

Definition at line 1969 of file Assembly.C.

{
  const auto elem_dimension = elem->dim();
  auto rule = qruleFace(elem, side);
  if (_current_qrule_face != rule)
    setFaceQRule(rule, elem_dimension);
}

setFaceQRule() [2/2]

void Assembly::setFaceQRule	(	libMesh::QBase *	qrule,
		unsigned int	dim
	)

Set the qrule to be used for face integration.

Note: This is normally set internally, only use if you know what you are doing!

Parameters

qrule	The qrule you want to set
dim	The spatial dimension of the qrule

Referenced by reinit(), reinit(), reinitElemFaceRef(), reinitFVFace(), setFaceQRule(), and setLowerQRule().

setLowerQRule()

void Assembly::setLowerQRule ( libMesh::QBase *  qrule, unsigned int  dim  )

private

Set the qrule to be used for lower dimensional integration.

Parameters

qrule	The qrule you want to set
dim	The spatial dimension of the qrule

Definition at line 727 of file Assembly.C.

{
  // The lower-dimensional quadrature rule matches the face quadrature rule
  setFaceQRule(qrule, dim);
 
  _current_qrule_lower = qrule;
 
  for (auto & it : _fe_lower[dim])
    it.second->attach_quadrature_rule(qrule);
  for (auto & it : _vector_fe_lower[dim])
    it.second->attach_quadrature_rule(qrule);
  if (!_unique_fe_lower_helper.empty())
  {
    mooseAssert(dim < _unique_fe_lower_helper.size(), "We should not be indexing out of bounds");
    _unique_fe_lower_helper[dim]->attach_quadrature_rule(qrule);
  }
}

Referenced by reinitLowerDElem().

setMortarQRule()

void Assembly::setMortarQRule

(

Order

order

)

Specifies a custom qrule for integration on mortar segment mesh.

Used to properly integrate QUAD face elements using quadrature on TRI mortar segment elements. For example, to exactly integrate a FIRST order QUAD element, SECOND order quadrature on TRI mortar segments is needed.

Definition at line 772 of file Assembly.C.

{
  if (order != _qrule_msm->get_order())
  {
    // If custom mortar qrule has not yet been specified
    if (!_custom_mortar_qrule)
    {
      _custom_mortar_qrule = true;
      const unsigned int dim = _qrule_msm->get_dim();
      const QuadratureType type = _qrule_msm->type();
      delete _qrule_msm;
 
      _qrule_msm = QBase::build(type, dim, order).release();
      _fe_msm->attach_quadrature_rule(_qrule_msm);
    }
    else
      mooseError("Mortar quadrature_order: ",
                 order,
                 " does not match previously specified quadrature_order: ",
                 _qrule_msm->get_order(),
                 ". Quadrature_order (when specified) must match for all mortar constraints.");
  }
}

Referenced by MortarConstraintBase::MortarConstraintBase().

setNeighborQRule()

void Assembly::setNeighborQRule	(	libMesh::QBase *	qrule,
		unsigned int	dim
	)

Set the qrule to be used for neighbor integration.

Note: This is normally set internally, only use if you know what you are doing!

Parameters

qrule	The qrule you want to set
dim	The spatial dimension of the qrule

Definition at line 746 of file Assembly.C.

{
  _current_qrule_neighbor = qrule;
 
  for (auto & it : _fe_face_neighbor[dim])
    it.second->attach_quadrature_rule(qrule);
  for (auto & it : _vector_fe_face_neighbor[dim])
    it.second->attach_quadrature_rule(qrule);
  if (!_unique_fe_face_neighbor_helper.empty())
  {
    mooseAssert(dim < _unique_fe_face_neighbor_helper.size(),
                "We should not be indexing out of bounds");
    _unique_fe_face_neighbor_helper[dim]->attach_quadrature_rule(qrule);
  }
}

Referenced by reinitFVFace(), reinitNeighbor(), and reinitNeighborFaceRef().

setResidual()

void Assembly::setResidual	(	NumericVector< Number > &	residual,
		GlobalDataKey	,
		const VectorTag &	vector_tag
	)

Sets local residuals of all field variables to the global residual vector for a tag.

Definition at line 3585 of file Assembly.C.

{
  auto & tag_Re = _sub_Re[vector_tag._type_id];
  const std::vector<MooseVariableFEBase *> & vars = _sys.getVariables(_tid);
  for (const auto & var : vars)
    setResidualBlock(residual, tag_Re[var->number()], var->dofIndices(), var->arrayScalingFactor());
}

setResidualBlock()

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

private

Set a local residual block to a global residual vector with proper scaling.

Definition at line 3341 of file Assembly.C.

{
  if (dof_indices.size() > 0)
  {
    std::vector<dof_id_type> di(dof_indices);
    _tmp_Re = res_block;
    processLocalResidual(_tmp_Re, di, scaling_factor);
    residual.insert(_tmp_Re, di);
  }
}

Referenced by setResidual(), and setResidualNeighbor().

setResidualNeighbor()

void Assembly::setResidualNeighbor	(	NumericVector< Number > &	residual,
		GlobalDataKey	,
		const VectorTag &	vector_tag
	)

Sets local neighbor residuals of all field variables to the global residual vector for a tag.

Definition at line 3594 of file Assembly.C.

{
  auto & tag_Rn = _sub_Rn[vector_tag._type_id];
  const std::vector<MooseVariableFEBase *> & vars = _sys.getVariables(_tid);
  for (const auto & var : vars)
    setResidualBlock(
        residual, tag_Rn[var->number()], var->dofIndicesNeighbor(), var->arrayScalingFactor());
}

setVolumeQRule() [1/2]

void Assembly::setVolumeQRule

(

const Elem *

elem

)

Set the volumetric quadrature rule based on the provided element.

Definition at line 1848 of file Assembly.C.

{
  unsigned int elem_dimension = elem->dim();
  _current_qrule_volume = qrules(elem_dimension).vol.get();
  // Make sure the qrule is the right one
  if (_current_qrule != _current_qrule_volume)
    setVolumeQRule(_current_qrule_volume, elem_dimension);
}

setVolumeQRule() [2/2]

void Assembly::setVolumeQRule	(	libMesh::QBase *	qrule,
		unsigned int	dim
	)

Set the qrule to be used for volume integration.

Note: This is normally set internally, only use if you know what you are doing!

Parameters

qrule	The qrule you want to set
dim	The spatial dimension of the qrule

Referenced by reinit(), reinit(), and setVolumeQRule().

setXFEM()

void Assembly::setXFEM ( std::shared_ptr< XFEMInterface >  xfem )

inline

Set the pointer to the XFEM controller object.

Definition at line 1799 of file Assembly.h.

{ _xfem = xfem; }

side()

const unsigned int & Assembly::side ( ) const

inline

Returns the current side.

Returns

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

Definition at line 438 of file Assembly.h.

{ return _current_side; }

Referenced by computeADFace(), computeFaceMap(), modifyFaceWeightsDueToXFEM(), qruleArbitraryFace(), qruleFace(), qruleFaceHelper(), reinit(), reinit(), reinitElemAndNeighbor(), reinitFEFace(), and setFaceQRule().

sideElem()

const Elem *const & Assembly::sideElem ( ) const

inline

Returns the side element.

Returns

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

Definition at line 450 of file Assembly.h.

{ return _current_side_elem; }

sideElemVolume()

const Real & Assembly::sideElemVolume ( ) const

inline

Returns the reference to the volume of current side element.

Returns

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

Definition at line 456 of file Assembly.h.

{ return _current_side_volume; }

tangents()

const MooseArray< std::vector< Point > > & Assembly::tangents ( ) const

inline

Returns the array of tangents for quadrature points on a current side.

Returns

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

Definition at line 360 of file Assembly.h.

{ return _current_tangents; }

writeableQRule() [1/2]

libMesh::QBase *const & Assembly::writeableQRule ( )

inline

Returns the reference to the current quadrature being used.

Returns

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

Definition at line 233 of file Assembly.h.

{ return _current_qrule; }

Referenced by MooseMesh::buildHRefinementAndCoarseningMaps(), and MooseMesh::buildPRefinementAndCoarseningMaps().

writeableQRule() [2/2]

libMesh::QBase * Assembly::writeableQRule ( unsigned int  dim, SubdomainID  block, InternalDataKey    )

inline

Returns the pointer to the quadrature of specified block and dimension.

Returns

A pointer.

Definition at line 240 of file Assembly.h.

  {
    return qrules(dim, block).vol.get();
  }

writeableQRuleFace() [1/2]

libMesh::QBase *const & Assembly::writeableQRuleFace ( )

inline

Returns the reference to the current quadrature being used on a current face.

Returns

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

Definition at line 320 of file Assembly.h.

{ return _current_qrule_face; }

Referenced by MooseMesh::buildHRefinementAndCoarseningMaps(), and MooseMesh::buildPRefinementAndCoarseningMaps().

writeableQRuleFace() [2/2]

libMesh::QBase * Assembly::writeableQRuleFace ( unsigned int  dim, SubdomainID  block, InternalDataKey    )

inline

Returns the pointer to the quadrature used on a face of specified block and dimension.

Returns

A pointer.

Definition at line 327 of file Assembly.h.

  {
    return qrules(dim, block).face.get();
  }

writeableQRuleNeighbor()

libMesh::QBase *const & Assembly::writeableQRuleNeighbor ( )

inline

Returns the reference to the current quadrature being used on a current neighbor.

Returns

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

Definition at line 519 of file Assembly.h.

{ return _current_qrule_neighbor; }

zeroCachedJacobian()

void Assembly::zeroCachedJacobian

(

GlobalDataKey

)

Zero out previously-cached Jacobian rows.

Definition at line 4548 of file Assembly.C.

{
  for (MooseIndex(_cached_jacobian_rows) tag = 0; tag < _cached_jacobian_rows.size(); tag++)
    if (_sys.hasMatrix(tag))
      _sys.getMatrix(tag).zero_rows(_cached_jacobian_rows[tag], 0.0);
 
  clearCachedJacobian();
}

Member Data Documentation

_ad_coord

MooseArray<ADReal> Assembly::_ad_coord

private

The AD version of the current coordinate transformation coefficients.

Definition at line 2414 of file Assembly.h.

Referenced by adCoordTransformation(), computeCurrentElemVolume(), computeCurrentFaceVolume(), and ~Assembly().

_ad_curvatures

MooseArray<ADReal> Assembly::_ad_curvatures

protected

Definition at line 2842 of file Assembly.h.

Referenced by adCurvatures(), computeADFace(), computeFaceMap(), and ~Assembly().

_ad_d2xyzdeta2_map

std::vector<VectorValue<ADReal> > Assembly::_ad_d2xyzdeta2_map

protected

Definition at line 2824 of file Assembly.h.

Referenced by computeFaceMap().

_ad_d2xyzdxi2_map

std::vector<VectorValue<ADReal> > Assembly::_ad_d2xyzdxi2_map

protected

Definition at line 2822 of file Assembly.h.

Referenced by computeFaceMap().

_ad_d2xyzdxideta_map

std::vector<VectorValue<ADReal> > Assembly::_ad_d2xyzdxideta_map

protected

Definition at line 2823 of file Assembly.h.

Referenced by computeFaceMap().

_ad_detadx_map

std::vector<ADReal> Assembly::_ad_detadx_map

protected

Definition at line 2831 of file Assembly.h.

Referenced by computeGradPhiAD(), computeSinglePointMapAD(), and resizeADMappingObjects().

_ad_detady_map

std::vector<ADReal> Assembly::_ad_detady_map

protected

Definition at line 2832 of file Assembly.h.

Referenced by computeGradPhiAD(), computeSinglePointMapAD(), and resizeADMappingObjects().

_ad_detadz_map

std::vector<ADReal> Assembly::_ad_detadz_map

protected

Definition at line 2833 of file Assembly.h.

Referenced by computeGradPhiAD(), computeSinglePointMapAD(), and resizeADMappingObjects().

_ad_dxidx_map

std::vector<ADReal> Assembly::_ad_dxidx_map

protected

Definition at line 2828 of file Assembly.h.

Referenced by computeGradPhiAD(), computeSinglePointMapAD(), and resizeADMappingObjects().

_ad_dxidy_map

std::vector<ADReal> Assembly::_ad_dxidy_map

protected

Definition at line 2829 of file Assembly.h.

Referenced by computeGradPhiAD(), computeSinglePointMapAD(), and resizeADMappingObjects().

_ad_dxidz_map

std::vector<ADReal> Assembly::_ad_dxidz_map

protected

Definition at line 2830 of file Assembly.h.

Referenced by computeGradPhiAD(), computeSinglePointMapAD(), and resizeADMappingObjects().

_ad_dxyzdeta_map

std::vector<VectorValue<ADReal> > Assembly::_ad_dxyzdeta_map

protected

Definition at line 2820 of file Assembly.h.

Referenced by computeFaceMap(), computeSinglePointMapAD(), and resizeADMappingObjects().

_ad_dxyzdxi_map

std::vector<VectorValue<ADReal> > Assembly::_ad_dxyzdxi_map

protected

AD quantities.

Definition at line 2819 of file Assembly.h.

Referenced by computeFaceMap(), computeSinglePointMapAD(), and resizeADMappingObjects().

_ad_dxyzdzeta_map

std::vector<VectorValue<ADReal> > Assembly::_ad_dxyzdzeta_map

protected

Definition at line 2821 of file Assembly.h.

Referenced by computeSinglePointMapAD(), and resizeADMappingObjects().

_ad_dzetadx_map

std::vector<ADReal> Assembly::_ad_dzetadx_map

protected

Definition at line 2834 of file Assembly.h.

Referenced by computeGradPhiAD(), computeSinglePointMapAD(), and resizeADMappingObjects().

_ad_dzetady_map

std::vector<ADReal> Assembly::_ad_dzetady_map

protected

Definition at line 2835 of file Assembly.h.

Referenced by computeGradPhiAD(), computeSinglePointMapAD(), and resizeADMappingObjects().

_ad_dzetadz_map

std::vector<ADReal> Assembly::_ad_dzetadz_map

protected

Definition at line 2836 of file Assembly.h.

Referenced by computeGradPhiAD(), computeSinglePointMapAD(), and resizeADMappingObjects().

_ad_grad_phi_data

std::map<FEType, ADTemplateVariablePhiGradient<Real> > Assembly::_ad_grad_phi_data

mutableprotected

Definition at line 2768 of file Assembly.h.

Referenced by adGradPhi(), feADGradPhi(), reinitFE(), and ~Assembly().

_ad_grad_phi_data_face

std::map<FEType, ADTemplateVariablePhiGradient<Real> > Assembly::_ad_grad_phi_data_face

mutableprotected

Definition at line 2770 of file Assembly.h.

Referenced by computeADFace(), feADGradPhiFace(), and ~Assembly().

_ad_jac

std::vector<ADReal> Assembly::_ad_jac

protected

Definition at line 2825 of file Assembly.h.

Referenced by computeSinglePointMapAD(), and resizeADMappingObjects().

_ad_JxW

MooseArray<ADReal> Assembly::_ad_JxW

protected

Definition at line 2826 of file Assembly.h.

Referenced by adJxW(), computeSinglePointMapAD(), reinitFE(), resizeADMappingObjects(), and ~Assembly().

_ad_JxW_face

MooseArray<ADReal> Assembly::_ad_JxW_face

protected

Definition at line 2838 of file Assembly.h.

Referenced by adJxWFace(), computeADFace(), computeFaceMap(), and ~Assembly().

_ad_normals

MooseArray<VectorValue<ADReal> > Assembly::_ad_normals

protected

Definition at line 2839 of file Assembly.h.

Referenced by adNormals(), computeADFace(), computeFaceMap(), and ~Assembly().

_ad_q_points

MooseArray<VectorValue<ADReal> > Assembly::_ad_q_points

protected

Definition at line 2827 of file Assembly.h.

Referenced by adQPoints(), computeCurrentElemVolume(), computeSinglePointMapAD(), reinitFE(), resizeADMappingObjects(), and ~Assembly().

_ad_q_points_face

MooseArray<VectorValue<ADReal> > Assembly::_ad_q_points_face

protected

Definition at line 2840 of file Assembly.h.

Referenced by adQPointsFace(), computeADFace(), computeCurrentFaceVolume(), computeFaceMap(), and ~Assembly().

_ad_vector_grad_phi_data

std::map<FEType, ADTemplateVariablePhiGradient<RealVectorValue> > Assembly::_ad_vector_grad_phi_data

mutableprotected

Definition at line 2769 of file Assembly.h.

Referenced by adGradPhi(), feADGradPhi(), reinitFE(), and ~Assembly().

_ad_vector_grad_phi_data_face

std::map<FEType, ADTemplateVariablePhiGradient<RealVectorValue> > Assembly::_ad_vector_grad_phi_data_face

mutableprotected

Definition at line 2772 of file Assembly.h.

Referenced by computeADFace(), feADGradPhiFace(), and ~Assembly().

_block_diagonal_matrix

bool Assembly::_block_diagonal_matrix

protected

Will be true if our preconditioning matrix is a block-diagonal matrix. Which means that we can take some shortcuts.

Definition at line 2807 of file Assembly.h.

Referenced by jacobianBlock(), jacobianBlockLowerUsed(), jacobianBlockLowerUsed(), jacobianBlockMortar(), jacobianBlockNeighbor(), jacobianBlockNeighborUsed(), jacobianBlockNeighborUsed(), jacobianBlockNonlocal(), jacobianBlockNonlocalUsed(), jacobianBlockNonlocalUsed(), jacobianBlockUsed(), and jacobianBlockUsed().

_building_helpers

bool Assembly::_building_helpers

private

Whether we are currently building the FE classes for the helpers.

Definition at line 2364 of file Assembly.h.

Referenced by Assembly(), buildFaceFE(), buildFaceNeighborFE(), buildFE(), buildLowerDFE(), and buildNeighborFE().

_cached_jacobian_cols

std::vector<std::vector<dof_id_type> > Assembly::_cached_jacobian_cols

protected

Column where the corresponding cached value should go.

Definition at line 2802 of file Assembly.h.

Referenced by addCachedJacobian(), cacheJacobian(), cacheJacobianBlock(), cacheJacobianBlockNonzero(), clearCachedJacobian(), and setCachedJacobian().

_cached_jacobian_rows

std::vector<std::vector<dof_id_type> > Assembly::_cached_jacobian_rows

protected

Row where the corresponding cached value should go.

Definition at line 2800 of file Assembly.h.

Referenced by addCachedJacobian(), cacheJacobian(), cacheJacobianBlock(), cacheJacobianBlockNonzero(), clearCachedJacobian(), setCachedJacobian(), and zeroCachedJacobian().

_cached_jacobian_values

std::vector<std::vector<Real> > Assembly::_cached_jacobian_values

protected

Values cached by calling cacheJacobian()

Definition at line 2798 of file Assembly.h.

Referenced by addCachedJacobian(), cacheJacobian(), cacheJacobianBlock(), cacheJacobianBlockNonzero(), clearCachedJacobian(), and setCachedJacobian().

_cached_residual_rows

std::vector<std::vector<dof_id_type> > Assembly::_cached_residual_rows

protected

Where the cached values should go (the first vector is for TIME vs NONTIME)

Definition at line 2793 of file Assembly.h.

Referenced by addCachedResidualDirectly(), addCachedResiduals(), cacheResidual(), cacheResidual(), cacheResidualLower(), cacheResidualNeighbor(), cacheResidualNodes(), and clearCachedResiduals().

_cached_residual_values

std::vector<std::vector<Real> > Assembly::_cached_residual_values

protected

Values cached by calling cacheResidual() (the first vector is for TIME vs NONTIME)

Definition at line 2790 of file Assembly.h.

Referenced by addCachedResidualDirectly(), addCachedResiduals(), cacheResidual(), cacheResidual(), cacheResidualLower(), cacheResidualNeighbor(), cacheResidualNodes(), and clearCachedResiduals().

_calculate_ad_coord

bool Assembly::_calculate_ad_coord

mutableprotected

Whether to calculate coord with AD.

This will only be set to true if a consumer calls adCoordTransformation()

Definition at line 2855 of file Assembly.h.

Referenced by adCoordTransformation(), computeCurrentElemVolume(), and computeCurrentFaceVolume().

_calculate_curvatures

bool Assembly::_calculate_curvatures

mutableprotected

Definition at line 2851 of file Assembly.h.

Referenced by adCurvatures(), computeADFace(), computeFaceMap(), reinitElemFaceRef(), and reinitFEFace().

_calculate_face_xyz

bool Assembly::_calculate_face_xyz

mutableprotected

Definition at line 2850 of file Assembly.h.

Referenced by adCoordTransformation(), adQPointsFace(), computeADFace(), and computeFaceMap().

_calculate_xyz

bool Assembly::_calculate_xyz

mutableprotected

Definition at line 2849 of file Assembly.h.

Referenced by adCoordTransformation(), adQPoints(), computeSinglePointMapAD(), reinitFE(), and resizeADMappingObjects().

_cm

const libMesh::CouplingMatrix* Assembly::_cm

private

Coupling matrices.

Definition at line 2306 of file Assembly.h.

Referenced by addJacobianBlock(), addJacobianBlockNonlocal(), cacheJacobianBlock(), and cacheJacobianBlockNonzero().

_cm_ff_entry

std::vector<std::pair<MooseVariableFieldBase *, MooseVariableFieldBase *> > Assembly::_cm_ff_entry

private

Entries in the coupling matrix for field variables.

Definition at line 2319 of file Assembly.h.

Referenced by addJacobian(), addJacobianLowerD(), addJacobianNeighbor(), addJacobianNeighborLowerD(), cacheJacobian(), cacheJacobianMortar(), cacheJacobianNeighbor(), couplingEntries(), couplingEntries(), prepareJacobianBlock(), prepareLowerD(), prepareNeighbor(), and prepareVariable().

_cm_fs_entry

std::vector<std::pair<MooseVariableFieldBase *, MooseVariableScalar *> > Assembly::_cm_fs_entry

private

Entries in the coupling matrix for field variables vs scalar variables.

Definition at line 2321 of file Assembly.h.

Referenced by addJacobian(), cacheJacobian(), and fieldScalarCouplingEntries().

_cm_nonlocal_entry

std::vector<std::pair<MooseVariableFieldBase *, MooseVariableFieldBase *> > Assembly::_cm_nonlocal_entry

private

Entries in the coupling matrix for field variables for nonlocal calculations.

Definition at line 2327 of file Assembly.h.

Referenced by addJacobianNonlocal(), cacheJacobianNonlocal(), initNonlocalCoupling(), nonlocalCouplingEntries(), prepareNonlocal(), and prepareVariableNonlocal().

_cm_sf_entry

std::vector<std::pair<MooseVariableScalar *, MooseVariableFieldBase *> > Assembly::_cm_sf_entry

private

Entries in the coupling matrix for scalar variables vs field variables.

Definition at line 2323 of file Assembly.h.

Referenced by addJacobian(), addJacobianOffDiagScalar(), cacheJacobian(), and scalarFieldCouplingEntries().

_cm_ss_entry

std::vector<std::pair<MooseVariableScalar *, MooseVariableScalar *> > Assembly::_cm_ss_entry

private

Entries in the coupling matrix for scalar variables.

Definition at line 2325 of file Assembly.h.

Referenced by addJacobianScalar().

_column_indices

std::vector<dof_id_type> Assembly::_column_indices

protected

Definition at line 2887 of file Assembly.h.

Referenced by cacheJacobian(), and cacheJacobianBlock().

_component_block_diagonal

std::vector<bool> Assembly::_component_block_diagonal

protected

An flag array Indiced by variable index to show if there is no component-wise coupling for the variable.

Definition at line 2810 of file Assembly.h.

Referenced by addJacobianBlock(), addJacobianBlockNonlocal(), cacheJacobianBlock(), cacheJacobianBlockNonzero(), prepareBlock(), prepareBlockNonlocal(), prepareJacobianBlock(), prepareLowerD(), prepareNeighbor(), prepareNonlocal(), prepareVariable(), prepareVariableNonlocal(), saveDiagLocalArrayJacobian(), and saveFullLocalArrayJacobian().

_compute_face_map_side_elem_builder

libMesh::ElemSideBuilder Assembly::_compute_face_map_side_elem_builder

protected

In place side element builder for computeFaceMap()

Definition at line 2870 of file Assembly.h.

Referenced by computeFaceMap().

_computing_jacobian

const bool& Assembly::_computing_jacobian

private

Whether we are currently computing the Jacobian.

Definition at line 2313 of file Assembly.h.

Referenced by computingJacobian().

_computing_residual

const bool& Assembly::_computing_residual

private

Whether we are currently computing the residual.

Definition at line 2310 of file Assembly.h.

Referenced by computingResidual().

_computing_residual_and_jacobian

const bool& Assembly::_computing_residual_and_jacobian

private

Whether we are currently computing the residual and Jacobian.

Definition at line 2316 of file Assembly.h.

Referenced by computingResidualAndJacobian().

_coord

MooseArray<Real> Assembly::_coord

private

The current coordinate transformation coefficients.

Definition at line 2412 of file Assembly.h.

Referenced by computeCurrentElemVolume(), computeCurrentFaceVolume(), coordTransformation(), and ~Assembly().

_coord_msm

MooseArray<Real> Assembly::_coord_msm

private

The coordinate transformation coefficients evaluated on the quadrature points of the mortar segment mesh.

Definition at line 2562 of file Assembly.h.

Referenced by mortarCoordTransformation(), reinitMortarElem(), and ~Assembly().

_coord_neighbor

MooseArray<Real> Assembly::_coord_neighbor

private

The current coordinate transformation coefficients.

Definition at line 2559 of file Assembly.h.

Referenced by reinitNeighbor(), and ~Assembly().

_coord_type

Moose::CoordinateSystemType Assembly::_coord_type

private

The coordinate system.

Definition at line 2410 of file Assembly.h.

Referenced by coordSystem(), and setCoordinateTransformation().

_current_boundary_id

BoundaryID Assembly::_current_boundary_id

protected

The current boundary ID.

Definition at line 2588 of file Assembly.h.

Referenced by currentBoundaryID(), and setCurrentBoundaryID().

_current_elem

const Elem* Assembly::_current_elem

protected

The current "element" we are currently on.

Definition at line 2584 of file Assembly.h.

Referenced by computeCurrentElemVolume(), computeCurrentFaceVolume(), elem(), reinit(), reinit(), reinit(), reinit(), reinitAtPhysical(), reinitElemFaceRef(), reinitFE(), reinitFEFace(), and reinitFVFace().

_current_elem_volume

Real Assembly::_current_elem_volume

protected

Volume of the current element.

Definition at line 2590 of file Assembly.h.

Referenced by computeCurrentElemVolume(), and elemVolume().

_current_elem_volume_computed

bool Assembly::_current_elem_volume_computed

protected

Boolean to indicate whether current element volumes has been computed.

Definition at line 2614 of file Assembly.h.

Referenced by computeCurrentElemVolume(), reinit(), reinit(), reinit(), reinit(), reinitAtPhysical(), and reinitFVFace().

_current_fe

std::map<FEType, FEBase *> Assembly::_current_fe

private

The "volume" fe object that matches the current elem.

Definition at line 2370 of file Assembly.h.

Referenced by reinitFE().

_current_fe_face

std::map<FEType, FEBase *> Assembly::_current_fe_face

private

The "face" fe object that matches the current elem.

Definition at line 2372 of file Assembly.h.

Referenced by reinitElemFaceRef(), and reinitFEFace().

_current_fe_face_helper

FEBase* Assembly::_current_fe_face_helper

private

helper object for transforming coordinates

Definition at line 2508 of file Assembly.h.

_current_fe_face_neighbor

std::map<FEType, FEBase *> Assembly::_current_fe_face_neighbor

private

The "neighbor face" fe object that matches the current elem.

Definition at line 2376 of file Assembly.h.

Referenced by reinitFEFaceNeighbor(), and reinitNeighborFaceRef().

_current_fe_helper

FEBase* Assembly::_current_fe_helper

private

The current helper object for transforming coordinates.

Definition at line 2396 of file Assembly.h.

_current_fe_neighbor

std::map<FEType, FEBase *> Assembly::_current_fe_neighbor

private

The "neighbor" fe object that matches the current elem.

Definition at line 2374 of file Assembly.h.

Referenced by reinitFENeighbor().

_current_JxW

MooseArray<Real> Assembly::_current_JxW

private

The current list of transformed jacobian weights.

Definition at line 2408 of file Assembly.h.

Referenced by computeCurrentElemVolume(), JxW(), modifyArbitraryWeights(), modifyWeightsDueToXFEM(), and reinitFE().

_current_JxW_face

MooseArray<Real> Assembly::_current_JxW_face

private

The current transformed jacobian weights on a face.

Definition at line 2516 of file Assembly.h.

Referenced by computeADFace(), computeCurrentFaceVolume(), JxWFace(), modifyFaceWeightsDueToXFEM(), reinitElemFaceRef(), and reinitFEFace().

_current_JxW_neighbor

MooseArray<Real> Assembly::_current_JxW_neighbor

private

The current transformed jacobian weights on a neighbor's face.

Definition at line 2557 of file Assembly.h.

Referenced by JxWNeighbor(), and reinitNeighborAtPhysical().

_current_lower_d_elem

const Elem* Assembly::_current_lower_d_elem

protected

The current lower dimensional element.

Definition at line 2619 of file Assembly.h.

Referenced by lowerDElem(), reinitLowerDElem(), and setCurrentLowerDElem().

_current_lower_d_elem_volume

Real Assembly::_current_lower_d_elem_volume

protected

The current lower dimensional element volume.

Definition at line 2625 of file Assembly.h.

Referenced by lowerDElemVolume(), and reinitLowerDElem().

_current_neighbor_elem

const Elem* Assembly::_current_neighbor_elem

protected

The current neighbor "element".

Definition at line 2598 of file Assembly.h.

Referenced by neighbor(), reinit(), reinit(), reinit(), reinit(), reinitAtPhysical(), reinitFVFace(), reinitNeighbor(), and reinitNeighborFaceRef().

_current_neighbor_lower_d_elem

const Elem* Assembly::_current_neighbor_lower_d_elem

protected

The current neighboring lower dimensional element.

Definition at line 2621 of file Assembly.h.

Referenced by neighborLowerDElem(), and reinitNeighborLowerDElem().

_current_neighbor_lower_d_elem_volume

Real Assembly::_current_neighbor_lower_d_elem_volume

protected

The current neighboring lower dimensional element volume.

Definition at line 2629 of file Assembly.h.

Referenced by neighborLowerDElemVolume(), and reinitNeighborLowerDElem().

_current_neighbor_node

const Node* Assembly::_current_neighbor_node

protected

The current neighboring node we are working with.

Definition at line 2612 of file Assembly.h.

Referenced by nodeNeighbor(), and reinit().

_current_neighbor_ref_points

std::vector<Point> Assembly::_current_neighbor_ref_points

protected

The current reference points on the neighbor element.

Definition at line 2893 of file Assembly.h.

Referenced by reinitElemAndNeighbor(), reinitNeighborAtPhysical(), and reinitNeighborAtPhysical().

_current_neighbor_side

unsigned int Assembly::_current_neighbor_side

protected

The current side of the selected neighboring element (valid only when working with sides)

Definition at line 2602 of file Assembly.h.

Referenced by neighborSide(), reinitElemAndNeighbor(), and reinitFVFace().

_current_neighbor_side_elem

const Elem* Assembly::_current_neighbor_side_elem

protected

The current side element of the ncurrent neighbor element.

Definition at line 2604 of file Assembly.h.

Referenced by reinitElemAndNeighbor(), and reinitNeighborAtPhysical().

_current_neighbor_side_elem_builder

libMesh::ElemSideBuilder Assembly::_current_neighbor_side_elem_builder

protected

In place side element builder for _current_neighbor_side_elem.

Definition at line 2868 of file Assembly.h.

Referenced by reinitElemAndNeighbor(), and reinitNeighborAtPhysical().

_current_neighbor_subdomain_id

SubdomainID Assembly::_current_neighbor_subdomain_id

protected

The current neighbor subdomain ID.

Definition at line 2600 of file Assembly.h.

Referenced by currentNeighborSubdomainID(), reinitFVFace(), reinitNeighbor(), and setCurrentNeighborSubdomainID().

_current_neighbor_volume

Real Assembly::_current_neighbor_volume

protected

Volume of the current neighbor.

Definition at line 2608 of file Assembly.h.

Referenced by neighborVolume(), and reinitNeighbor().

_current_node

const Node* Assembly::_current_node

protected

The current node we are working with.

Definition at line 2610 of file Assembly.h.

Referenced by node(), and reinit().

_current_normals

MooseArray<Point> Assembly::_current_normals

private

The current Normal vectors at the quadrature points.

Definition at line 2518 of file Assembly.h.

Referenced by computeADFace(), normals(), reinitElemFaceRef(), and reinitFEFace().

_current_physical_points

MooseArray<Point> Assembly::_current_physical_points

protected

This will be filled up with the physical points passed into reinitAtPhysical() if it is called. Invalid at all other times.

Definition at line 2634 of file Assembly.h.

Referenced by modifyArbitraryWeights(), physicalPoints(), reinitAtPhysical(), reinitNeighborAtPhysical(), reinitNeighborAtPhysical(), and ~Assembly().

_current_q_points

MooseArray<Point> Assembly::_current_q_points

private

The current list of quadrature points.

Definition at line 2406 of file Assembly.h.

Referenced by computeCurrentElemVolume(), modifyWeightsDueToXFEM(), qPoints(), and reinitFE().

_current_q_points_face

MooseArray<Point> Assembly::_current_q_points_face

private

The current quadrature points on a face.

Definition at line 2514 of file Assembly.h.

Referenced by computeADFace(), computeCurrentFaceVolume(), modifyFaceWeightsDueToXFEM(), qPointsFace(), reinitElemAndNeighbor(), reinitElemFaceRef(), reinitFEFace(), and reinitFVFace().

_current_q_points_face_neighbor

MooseArray<Point> Assembly::_current_q_points_face_neighbor

private

The current quadrature points on the neighbor face.

Definition at line 2553 of file Assembly.h.

Referenced by qPointsFaceNeighbor(), reinitFEFaceNeighbor(), reinitFVFace(), and reinitNeighborFaceRef().

_current_qface_arbitrary

ArbitraryQuadrature* Assembly::_current_qface_arbitrary

private

The current arbitrary quadrature rule used on element faces.

Definition at line 2512 of file Assembly.h.

_current_qrule

libMesh::QBase* Assembly::_current_qrule

private

The current current quadrature rule being used (could be either volumetric or arbitrary - for dirac kernels)

Definition at line 2398 of file Assembly.h.

Referenced by clearCachedQRules(), computeCurrentElemVolume(), modifyArbitraryWeights(), modifyWeightsDueToXFEM(), qRule(), reinit(), reinitFE(), setVolumeQRule(), and writeableQRule().

_current_qrule_arbitrary

ArbitraryQuadrature* Assembly::_current_qrule_arbitrary

private

The current arbitrary quadrature rule used within the element interior.

Definition at line 2402 of file Assembly.h.

Referenced by modifyArbitraryWeights(), modifyFaceWeightsDueToXFEM(), modifyWeightsDueToXFEM(), reinit(), and reinit().

_current_qrule_arbitrary_face

ArbitraryQuadrature* Assembly::_current_qrule_arbitrary_face

private

The current arbitrary quadrature rule used on the element face.

Definition at line 2404 of file Assembly.h.

Referenced by reinit().

_current_qrule_face

libMesh::QBase* Assembly::_current_qrule_face

private

quadrature rule used on faces

Definition at line 2510 of file Assembly.h.

Referenced by clearCachedQRules(), computeADFace(), computeCurrentFaceVolume(), modifyFaceWeightsDueToXFEM(), qRuleFace(), reinit(), reinitElemFaceRef(), reinitFVFace(), setFaceQRule(), and writeableQRuleFace().

_current_qrule_lower

libMesh::QBase* Assembly::_current_qrule_lower

private

quadrature rule used on lower dimensional elements.

This should always be the same as the face qrule

Definition at line 2580 of file Assembly.h.

Referenced by clearCachedQRules(), reinitLowerDElem(), and setLowerQRule().

_current_qrule_neighbor

libMesh::QBase* Assembly::_current_qrule_neighbor

private

quadrature rule used on neighbors

Definition at line 2551 of file Assembly.h.

Referenced by clearCachedQRules(), qRuleNeighbor(), setNeighborQRule(), and writeableQRuleNeighbor().

_current_qrule_volume

libMesh::QBase* Assembly::_current_qrule_volume

private

The current volumetric quadrature for the element.

Definition at line 2400 of file Assembly.h.

Referenced by setVolumeQRule().

_current_side

unsigned int Assembly::_current_side

protected

The current side of the selected element (valid only when working with sides)

Definition at line 2592 of file Assembly.h.

Referenced by reinit(), reinit(), reinitElemFaceRef(), reinitFVFace(), and side().

_current_side_elem

const Elem* Assembly::_current_side_elem

protected

The current "element" making up the side we are currently on.

Definition at line 2594 of file Assembly.h.

Referenced by reinit(), reinit(), reinitElemFaceRef(), reinitFVFace(), and sideElem().

_current_side_elem_builder

libMesh::ElemSideBuilder Assembly::_current_side_elem_builder

protected

In place side element builder for _current_side_elem.

Definition at line 2866 of file Assembly.h.

Referenced by reinit(), reinit(), reinitElemFaceRef(), and reinitFVFace().

_current_side_volume

Real Assembly::_current_side_volume

protected

Volume of the current side element.

Definition at line 2596 of file Assembly.h.

Referenced by computeCurrentFaceVolume(), and sideElemVolume().

_current_side_volume_computed

bool Assembly::_current_side_volume_computed

protected

Boolean to indicate whether current element side volumes has been computed.

Definition at line 2616 of file Assembly.h.

Referenced by computeCurrentFaceVolume(), reinit(), reinit(), reinitElemFaceRef(), and reinitFVFace().

_current_subdomain_id

SubdomainID Assembly::_current_subdomain_id

protected

The current subdomain ID.

Definition at line 2586 of file Assembly.h.

Referenced by currentSubdomainID(), qrules(), reinit(), reinit(), reinit(), reinit(), reinitAtPhysical(), reinitFVFace(), and setCurrentSubdomainID().

_current_tangents

MooseArray<std::vector<Point> > Assembly::_current_tangents

private

The current tangent vectors at the quadrature points.

Definition at line 2522 of file Assembly.h.

Referenced by reinitElemFaceRef(), and tangents().

_current_vector_fe

std::map<FEType, FEVectorBase *> Assembly::_current_vector_fe

private

The "volume" vector fe object that matches the current elem.

Definition at line 2379 of file Assembly.h.

Referenced by reinitFE().

_current_vector_fe_face

std::map<FEType, FEVectorBase *> Assembly::_current_vector_fe_face

private

The "face" vector fe object that matches the current elem.

Definition at line 2381 of file Assembly.h.

Referenced by reinitElemFaceRef(), and reinitFEFace().

_current_vector_fe_face_neighbor

std::map<FEType, FEVectorBase *> Assembly::_current_vector_fe_face_neighbor

private

The "neighbor face" vector fe object that matches the current elem.

Definition at line 2385 of file Assembly.h.

Referenced by reinitFEFaceNeighbor(), and reinitNeighborFaceRef().

_current_vector_fe_neighbor

std::map<FEType, FEVectorBase *> Assembly::_current_vector_fe_neighbor

private

The "neighbor" vector fe object that matches the current elem.

Definition at line 2383 of file Assembly.h.

Referenced by reinitFENeighbor().

_curvatures

MooseArray<Real> Assembly::_curvatures

protected

Definition at line 2841 of file Assembly.h.

Referenced by computeADFace(), reinitElemFaceRef(), reinitFEFace(), and ~Assembly().

_custom_mortar_qrule

bool Assembly::_custom_mortar_qrule

private

Flag specifying whether a custom quadrature rule has been specified for mortar segment mesh.

Definition at line 2576 of file Assembly.h.

Referenced by createQRules(), and setMortarQRule().

_disp_numbers_and_directions

std::vector<std::pair<unsigned int, unsigned short> > Assembly::_disp_numbers_and_directions

protected

Container of displacement numbers and directions.

Definition at line 2847 of file Assembly.h.

Referenced by assignDisplacements(), computeFaceMap(), and computeSinglePointMapAD().

_displaced

const bool Assembly::_displaced

private

Definition at line 2303 of file Assembly.h.

Referenced by computeADFace(), and reinitFE().

_dof_map

const libMesh::DofMap& Assembly::_dof_map

private

DOF map.

Definition at line 2336 of file Assembly.h.

Referenced by addJacobianBlock(), cacheJacobian(), cacheJacobianBlock(), cacheJacobianBlock(), cacheJacobianBlockNonzero(), cacheResiduals(), and processLocalResidual().

_element_matrix

DenseMatrix<Number> Assembly::_element_matrix

protected

A working matrix to avoid repeated heap allocations when caching Jacobians that must have libMesh-level constraints (hanging nodes, periodic bcs) applied to them.

This stores local Jacobian values

Definition at line 2882 of file Assembly.h.

Referenced by cacheJacobian(), and cacheJacobianBlock().

_element_vector

DenseVector<Number> Assembly::_element_vector

protected

A working vector to avoid repeated heap allocations when caching residuals that must have libMesh-level constraints (hanging nodes, periodic bcs) applied to them.

This stores local residual values

Definition at line 2877 of file Assembly.h.

Referenced by cacheResiduals().

_extra_elem_ids

std::vector<dof_id_type> Assembly::_extra_elem_ids

private

Extra element IDs.

Definition at line 2525 of file Assembly.h.

Referenced by Assembly(), extraElemID(), numExtraElemIntegers(), reinitFE(), and reinitFEFace().

_fe

std::map<unsigned int, std::map<FEType, FEBase *> > Assembly::_fe

mutableprivate

Each dimension's actual fe objects indexed on type.

Definition at line 2390 of file Assembly.h.

Referenced by Assembly(), buildFE(), getFE(), preparePRefinement(), reinitFE(), and ~Assembly().

_fe_face

std::map<unsigned int, std::map<FEType, FEBase *> > Assembly::_fe_face

mutableprivate

types of finite elements

Definition at line 2502 of file Assembly.h.

Referenced by Assembly(), buildFaceFE(), computeADFace(), getFEFace(), preparePRefinement(), reinitElemFaceRef(), reinitFEFace(), and ~Assembly().

_fe_face_neighbor

std::map<unsigned int, std::map<FEType, FEBase *> > Assembly::_fe_face_neighbor

mutableprivate

Definition at line 2535 of file Assembly.h.

Referenced by Assembly(), buildFaceNeighborFE(), getFEFaceNeighbor(), preparePRefinement(), reinitFEFaceNeighbor(), reinitNeighborFaceRef(), setNeighborQRule(), and ~Assembly().

_fe_lower

std::map<unsigned int, std::map<FEType, FEBase *> > Assembly::_fe_lower

mutableprivate

FE objects for lower dimensional elements.

Definition at line 2544 of file Assembly.h.

Referenced by Assembly(), buildLowerDDualFE(), buildLowerDFE(), preparePRefinement(), reinitDual(), reinitLowerDElem(), setLowerQRule(), and ~Assembly().

_fe_msm

std::unique_ptr<FEBase> Assembly::_fe_msm

private

A FE object for working on mortar segement elements.

Definition at line 2569 of file Assembly.h.

Referenced by Assembly(), createQRules(), qPointsMortar(), reinitMortarElem(), and setMortarQRule().

_fe_neighbor

std::map<unsigned int, std::map<FEType, FEBase *> > Assembly::_fe_neighbor

mutableprivate

types of finite elements

Definition at line 2534 of file Assembly.h.

Referenced by Assembly(), buildNeighborFE(), getFENeighbor(), preparePRefinement(), reinitFENeighbor(), and ~Assembly().

_fe_shape_data

std::map<FEType, std::unique_ptr<FEShapeData> > Assembly::_fe_shape_data

mutableprotected

Shape function values, gradients, second derivatives for each FE type.

Definition at line 2753 of file Assembly.h.

Referenced by buildFE(), feCurlPhi(), feDivPhi(), feGradPhi(), fePhi(), feSecondPhi(), and reinitFE().

_fe_shape_data_dual_lower

std::map<FEType, std::unique_ptr<FEShapeData> > Assembly::_fe_shape_data_dual_lower

mutableprotected

Definition at line 2758 of file Assembly.h.

Referenced by buildLowerDDualFE(), feDualPhiLower(), feGradDualPhiLower(), reinitDual(), and reinitLowerDElem().

_fe_shape_data_face

std::map<FEType, std::unique_ptr<FEShapeData> > Assembly::_fe_shape_data_face

mutableprotected

Definition at line 2754 of file Assembly.h.

Referenced by buildFaceFE(), computeADFace(), feCurlPhiFace(), feDivPhiFace(), feGradPhiFace(), fePhiFace(), feSecondPhiFace(), reinitElemFaceRef(), and reinitFEFace().

_fe_shape_data_face_neighbor

std::map<FEType, std::unique_ptr<FEShapeData> > Assembly::_fe_shape_data_face_neighbor

mutableprotected

Definition at line 2756 of file Assembly.h.

Referenced by buildFaceNeighborFE(), feCurlPhiFaceNeighbor(), feDivPhiFaceNeighbor(), feGradPhiFaceNeighbor(), fePhiFaceNeighbor(), feSecondPhiFaceNeighbor(), reinitFEFaceNeighbor(), and reinitNeighborFaceRef().

_fe_shape_data_lower

std::map<FEType, std::unique_ptr<FEShapeData> > Assembly::_fe_shape_data_lower

mutableprotected

Definition at line 2757 of file Assembly.h.

Referenced by buildLowerDFE(), feGradPhiLower(), fePhiLower(), and reinitLowerDElem().

_fe_shape_data_neighbor

std::map<FEType, std::unique_ptr<FEShapeData> > Assembly::_fe_shape_data_neighbor

mutableprotected

Definition at line 2755 of file Assembly.h.

Referenced by buildNeighborFE(), feCurlPhiNeighbor(), feDivPhiNeighbor(), feGradPhiNeighbor(), fePhiNeighbor(), feSecondPhiNeighbor(), and reinitFENeighbor().

_grad_phi

VariablePhiGradient Assembly::_grad_phi

protected

Definition at line 2692 of file Assembly.h.

Referenced by gradPhi(), gradPhi(), gradPhi(), and gradPhi().

_grad_phi_face

VariablePhiGradient Assembly::_grad_phi_face

protected

Definition at line 2696 of file Assembly.h.

Referenced by gradPhiFace(), gradPhiFace(), gradPhiFace(), and gradPhiFace().

_grad_phi_face_neighbor

VariablePhiGradient Assembly::_grad_phi_face_neighbor

protected

Definition at line 2704 of file Assembly.h.

Referenced by gradPhiFaceNeighbor(), gradPhiFaceNeighbor(), and gradPhiFaceNeighbor().

_grad_phi_neighbor

VariablePhiGradient Assembly::_grad_phi_neighbor

protected

Definition at line 2700 of file Assembly.h.

Referenced by gradPhiNeighbor(), gradPhiNeighbor(), and gradPhiNeighbor().

_helper_type

const FEType Assembly::_helper_type

private

The finite element type of the FE helper classes.

The helper class gives us data like JxW, the physical quadrature point locations, etc.

Definition at line 2346 of file Assembly.h.

Referenced by adCurvatures(), Assembly(), buildFaceFE(), buildFaceNeighborFE(), buildFE(), buildLowerDFE(), buildNeighborFE(), and preparePRefinement().

_holder_fe_face_helper

std::map<unsigned int, FEBase *> Assembly::_holder_fe_face_helper

private

Each dimension's helper objects.

Definition at line 2506 of file Assembly.h.

Referenced by Assembly(), computeADFace(), computeFaceMap(), helpersRequestData(), preparePRefinement(), reinitElemFaceRef(), and reinitFEFace().

_holder_fe_face_neighbor_helper

std::map<unsigned int, FEBase *> Assembly::_holder_fe_face_neighbor_helper

private

Definition at line 2541 of file Assembly.h.

Referenced by Assembly(), helpersRequestData(), preparePRefinement(), reinitFEFaceNeighbor(), and reinitNeighborFaceRef().

_holder_fe_helper

std::map<unsigned int, FEBase *> Assembly::_holder_fe_helper

private

Each dimension's helper objects.

Definition at line 2394 of file Assembly.h.

Referenced by Assembly(), helpersRequestData(), preparePRefinement(), and reinitFE().

_holder_fe_lower_helper

std::map<unsigned int, FEBase *> Assembly::_holder_fe_lower_helper

private

helper object for transforming coordinates for lower dimensional element quadrature points

Definition at line 2548 of file Assembly.h.

Referenced by Assembly(), helpersRequestData(), preparePRefinement(), and reinitLowerDElem().

_holder_fe_neighbor_helper

std::map<unsigned int, FEBase *> Assembly::_holder_fe_neighbor_helper

private

Each dimension's helper objects.

Definition at line 2540 of file Assembly.h.

Referenced by Assembly(), helpersRequestData(), preparePRefinement(), and reinitNeighbor().

_holder_normals

std::map<unsigned int, const std::vector<Point> *> Assembly::_holder_normals

private

Holds pointers to the dimension's normal vectors.

Definition at line 2529 of file Assembly.h.

_jacobian_block_lower_used

std::vector<std::vector<std::vector<unsigned char> > > Assembly::_jacobian_block_lower_used

private

Flag that indicates if the jacobian block for the lower dimensional element was used.

Definition at line 2334 of file Assembly.h.

Referenced by addJacobianLowerD(), addJacobianNeighborLowerD(), cacheJacobianMortar(), jacobianBlockLowerUsed(), jacobianBlockLowerUsed(), and prepareLowerD().

_jacobian_block_neighbor_used

std::vector<std::vector<std::vector<unsigned char> > > Assembly::_jacobian_block_neighbor_used

private

Flag that indicates if the jacobian block for neighbor was used.

Definition at line 2332 of file Assembly.h.

Referenced by addJacobianNeighbor(), addJacobianNeighborLowerD(), cacheJacobianNeighbor(), jacobianBlockNeighborUsed(), jacobianBlockNeighborUsed(), and prepareNeighbor().

_jacobian_block_nonlocal_used

std::vector<std::vector<std::vector<unsigned char> > > Assembly::_jacobian_block_nonlocal_used

private

Definition at line 2330 of file Assembly.h.

Referenced by addJacobianNonlocal(), cacheJacobianNonlocal(), jacobianBlockNonlocalUsed(), jacobianBlockNonlocalUsed(), prepareBlockNonlocal(), prepareNonlocal(), and prepareVariableNonlocal().

_jacobian_block_used

std::vector<std::vector<std::vector<unsigned char> > > Assembly::_jacobian_block_used

private

Flag that indicates if the jacobian block was used.

Definition at line 2329 of file Assembly.h.

Referenced by addJacobianCoupledVarPair(), cacheJacobianCoupledVarPair(), jacobianBlockUsed(), jacobianBlockUsed(), prepareBlock(), prepareJacobianBlock(), prepareOffDiagScalar(), prepareScalar(), and prepareVariable().

_JxW_msm

const std::vector<Real>* Assembly::_JxW_msm

private

A JxW for working on mortar segement elements.

Definition at line 2567 of file Assembly.h.

Referenced by Assembly(), and jxWMortar().

_mapped_normals

std::vector<Eigen::Map<RealDIMValue> > Assembly::_mapped_normals

private

Mapped normals.

Definition at line 2520 of file Assembly.h.

Referenced by mappedNormals(), and reinitFEFace().

_max_cached_jacobians

unsigned int Assembly::_max_cached_jacobians

protected

Definition at line 2804 of file Assembly.h.

Referenced by addCachedJacobian().

_max_cached_residuals

unsigned int Assembly::_max_cached_residuals

protected

Definition at line 2795 of file Assembly.h.

Referenced by clearCachedResiduals().

_mesh

MooseMesh& Assembly::_mesh

private

Definition at line 2340 of file Assembly.h.

Referenced by Assembly().

_mesh_dimension

unsigned int Assembly::_mesh_dimension

private

Definition at line 2342 of file Assembly.h.

Referenced by Assembly(), buildFaceFE(), buildFaceNeighborFE(), buildFE(), buildLowerDDualFE(), buildLowerDFE(), buildNeighborFE(), buildVectorDualLowerDFE(), buildVectorFaceFE(), buildVectorFaceNeighborFE(), buildVectorFE(), buildVectorLowerDFE(), buildVectorNeighborFE(), bumpAllQRuleOrder(), bumpVolumeQRuleOrder(), createQRules(), helpersRequestData(), preparePRefinement(), reinitDual(), reinitLowerDElem(), reinitMortarElem(), reinitNeighborLowerDElem(), and ~Assembly().

_msm_elem

const Elem* Assembly::_msm_elem = nullptr

protected

Definition at line 2872 of file Assembly.h.

Referenced by msmElem(), and reinitMortarElem().

_need_ad_grad_phi_face

bool Assembly::_need_ad_grad_phi_face = false

mutableprotected

Whether any object needs the AD face shape function gradients.

Computing them on a displaced mesh propagates the displacement derivatives of the face map into every shape function gradient, which is expensive and unnecessary when only values and normals are used.

Definition at line 2776 of file Assembly.h.

Referenced by computeADFace(), and needADGradPhiFace().

_need_curl

std::set<FEType> Assembly::_need_curl

mutableprotected

Definition at line 2859 of file Assembly.h.

Referenced by buildVectorFaceFE(), buildVectorFaceNeighborFE(), buildVectorFE(), buildVectorNeighborFE(), feCurlPhi(), feCurlPhiFace(), feCurlPhiFaceNeighbor(), feCurlPhiNeighbor(), reinitElemFaceRef(), reinitFE(), reinitFEFace(), reinitFEFaceNeighbor(), reinitFENeighbor(), and reinitNeighborFaceRef().

_need_div

std::set<FEType> Assembly::_need_div

mutableprotected

Definition at line 2860 of file Assembly.h.

Referenced by buildVectorFE(), and reinitFE().

_need_dual

bool Assembly::_need_dual

protected

Whether dual shape functions need to be computed for mortar constraints.

Definition at line 2631 of file Assembly.h.

Referenced by activateDual(), and needDual().

_need_face_div

std::set<FEType> Assembly::_need_face_div

mutableprotected

Definition at line 2861 of file Assembly.h.

Referenced by buildVectorFaceFE(), reinitElemFaceRef(), and reinitFEFace().

_need_face_neighbor_div

std::set<FEType> Assembly::_need_face_neighbor_div

mutableprotected

Definition at line 2863 of file Assembly.h.

Referenced by buildVectorFaceNeighborFE(), reinitFEFaceNeighbor(), and reinitNeighborFaceRef().

_need_JxW_neighbor

bool Assembly::_need_JxW_neighbor

mutableprivate

Flag to indicate that JxW_neighbor is needed.

Definition at line 2555 of file Assembly.h.

Referenced by JxWNeighbor(), and reinitNeighborAtPhysical().

_need_lower_d_elem_volume

bool Assembly::_need_lower_d_elem_volume

mutableprotected

Whether we need to compute the lower dimensional element volume.

Definition at line 2623 of file Assembly.h.

Referenced by lowerDElemVolume(), and reinitLowerDElem().

_need_neighbor_div

std::set<FEType> Assembly::_need_neighbor_div

mutableprotected

Definition at line 2862 of file Assembly.h.

Referenced by buildVectorNeighborFE(), and reinitFENeighbor().

_need_neighbor_elem_volume

bool Assembly::_need_neighbor_elem_volume

mutableprotected

true is apps need to compute neighbor element volume

Definition at line 2606 of file Assembly.h.

Referenced by neighborVolume(), and reinitNeighbor().

_need_neighbor_lower_d_elem_volume

bool Assembly::_need_neighbor_lower_d_elem_volume

mutableprotected

Whether we need to compute the neighboring lower dimensional element volume.

Definition at line 2627 of file Assembly.h.

Referenced by neighborLowerDElemVolume(), and reinitNeighborLowerDElem().

_need_second_derivative

std::set<FEType> Assembly::_need_second_derivative

mutableprotected

Definition at line 2857 of file Assembly.h.

Referenced by buildFaceFE(), buildFE(), buildLowerDDualFE(), buildLowerDFE(), buildVectorDualLowerDFE(), buildVectorLowerDFE(), feSecondPhi(), feSecondPhiFace(), reinitElemFaceRef(), reinitFE(), reinitFEFace(), reinitFEFaceNeighbor(), reinitFENeighbor(), and reinitNeighborFaceRef().

_need_second_derivative_neighbor

std::set<FEType> Assembly::_need_second_derivative_neighbor

mutableprotected

Definition at line 2858 of file Assembly.h.

Referenced by buildFaceNeighborFE(), buildNeighborFE(), feSecondPhiFaceNeighbor(), feSecondPhiNeighbor(), reinitElemFaceRef(), reinitFEFaceNeighbor(), reinitFENeighbor(), reinitLowerDElem(), and reinitNeighborFaceRef().

_neighbor_extra_elem_ids

std::vector<dof_id_type> Assembly::_neighbor_extra_elem_ids

private

Extra element IDs of neighbor.

Definition at line 2527 of file Assembly.h.

Referenced by Assembly(), extraElemIDNeighbor(), and reinitNeighbor().

_nonlocal_cm

const libMesh::CouplingMatrix& Assembly::_nonlocal_cm

private

Definition at line 2307 of file Assembly.h.

Referenced by initNonlocalCoupling().

_phi

VariablePhiValue Assembly::_phi

protected

Definition at line 2691 of file Assembly.h.

Referenced by phi(), phi(), phi(), and phi().

_phi_face

VariablePhiValue Assembly::_phi_face

protected

Definition at line 2695 of file Assembly.h.

Referenced by phiFace(), phiFace(), phiFace(), and phiFace().

_phi_face_neighbor

VariablePhiValue Assembly::_phi_face_neighbor

protected

Definition at line 2703 of file Assembly.h.

Referenced by phiFaceNeighbor(), phiFaceNeighbor(), and phiFaceNeighbor().

_phi_neighbor

VariablePhiValue Assembly::_phi_neighbor

protected

Definition at line 2699 of file Assembly.h.

Referenced by phiNeighbor(), phiNeighbor(), and phiNeighbor().

_prepared_for_p_refinement

bool Assembly::_prepared_for_p_refinement

protected

Whether helper FEs have been prepared for p-refinement.

Definition at line 2890 of file Assembly.h.

Referenced by preparePRefinement().

_qrule_msm

libMesh::QBase* Assembly::_qrule_msm

private

A qrule object for working on mortar segement elements.

This needs to be a raw pointer because we need to be able to return a reference to it because we will be constructing other objects that need the qrule before the qrule is actually created

Definition at line 2574 of file Assembly.h.

Referenced by createQRules(), qRuleMortar(), reinitMortarElem(), setMortarQRule(), and ~Assembly().

_qrules

std::unordered_map<SubdomainID, std::vector<QRules> > Assembly::_qrules

private

Holds quadrature rules for each dimension.

These are created up front at the start of the simulation and reused/referenced for the remainder of the sim. This data structure should generally be read/accessed via the qrules() function.

Definition at line 2447 of file Assembly.h.

Referenced by bumpAllQRuleOrder(), bumpVolumeQRuleOrder(), createQRules(), and qrules().

_residual_vector_tags

const std::vector<VectorTag>& Assembly::_residual_vector_tags

protected

The residual vector tags that Assembly could possibly contribute to.

The following variables are all indexed with this vector (i.e., index 0 in the following vectors corresponds to the tag with TagID _residual_vector_tags[0]._id): _sub_Re, _sub_Rn, _sub_Rl, _cached_residual_rows, _cached_residual_values,

This index is also available in VectorTag::_type_id

Definition at line 2787 of file Assembly.h.

Referenced by clearCachedResiduals().

_row_indices

std::vector<dof_id_type> Assembly::_row_indices

protected

Working vectors to avoid repeated heap allocations when caching residuals/Jacobians that must have libMesh-level constraints (hanging nodes, periodic bcs) applied to them.

These are for storing the dof indices

Definition at line 2887 of file Assembly.h.

Referenced by cacheJacobian(), cacheJacobianBlock(), and cacheResiduals().

_second_phi

VariablePhiSecond Assembly::_second_phi

protected

Definition at line 2693 of file Assembly.h.

Referenced by secondPhi(), secondPhi(), secondPhi(), and secondPhi().

_second_phi_face

VariablePhiSecond Assembly::_second_phi_face

protected

Definition at line 2697 of file Assembly.h.

Referenced by secondPhiFace(), secondPhiFace(), and secondPhiFace().

_second_phi_face_neighbor

VariablePhiSecond Assembly::_second_phi_face_neighbor

protected

Definition at line 2705 of file Assembly.h.

Referenced by secondPhiFaceNeighbor(), secondPhiFaceNeighbor(), and secondPhiFaceNeighbor().

_second_phi_neighbor

VariablePhiSecond Assembly::_second_phi_neighbor

protected

Definition at line 2701 of file Assembly.h.

Referenced by secondPhiNeighbor(), secondPhiNeighbor(), and secondPhiNeighbor().

_sub_Kee

std::vector<std::vector<std::vector<DenseMatrix<Number> > > > Assembly::_sub_Kee

protected

Definition at line 2667 of file Assembly.h.

Referenced by jacobianBlock(), jacobianBlockMortar(), and jacobianBlockNeighbor().

_sub_Keg

std::vector<std::vector<std::vector<DenseMatrix<Number> > > > Assembly::_sub_Keg

protected

Definition at line 2668 of file Assembly.h.

Referenced by jacobianBlockNonlocal().

_sub_Kel

std::vector<std::vector<std::vector<DenseMatrix<Number> > > > Assembly::_sub_Kel

protected

dsecondary/dlower (or delement/dlower)

Definition at line 2683 of file Assembly.h.

Referenced by jacobianBlockMortar().

_sub_Ken

std::vector<std::vector<std::vector<DenseMatrix<Number> > > > Assembly::_sub_Ken

protected

jacobian contributions from the element and neighbor <Tag, ivar, jvar>

Definition at line 2671 of file Assembly.h.

Referenced by jacobianBlockMortar(), and jacobianBlockNeighbor().

_sub_Kle

std::vector<std::vector<std::vector<DenseMatrix<Number> > > > Assembly::_sub_Kle

protected

dlower/dsecondary (or dlower/delement)

Definition at line 2679 of file Assembly.h.

Referenced by jacobianBlockMortar().

_sub_Kll

std::vector<std::vector<std::vector<DenseMatrix<Number> > > > Assembly::_sub_Kll

protected

dlower/dlower

Definition at line 2677 of file Assembly.h.

Referenced by jacobianBlockMortar().

_sub_Kln

std::vector<std::vector<std::vector<DenseMatrix<Number> > > > Assembly::_sub_Kln

protected

dlower/dprimary (or dlower/dneighbor)

Definition at line 2681 of file Assembly.h.

Referenced by jacobianBlockMortar().

_sub_Kne

std::vector<std::vector<std::vector<DenseMatrix<Number> > > > Assembly::_sub_Kne

protected

jacobian contributions from the neighbor and element <Tag, ivar, jvar>

Definition at line 2673 of file Assembly.h.

Referenced by jacobianBlockMortar(), and jacobianBlockNeighbor().

_sub_Knl

std::vector<std::vector<std::vector<DenseMatrix<Number> > > > Assembly::_sub_Knl

protected

dprimary/dlower (or dneighbor/dlower)

Definition at line 2685 of file Assembly.h.

Referenced by jacobianBlockMortar().

_sub_Knn

std::vector<std::vector<std::vector<DenseMatrix<Number> > > > Assembly::_sub_Knn

protected

jacobian contributions from the neighbor <Tag, ivar, jvar>

Definition at line 2675 of file Assembly.h.

Referenced by jacobianBlockMortar(), and jacobianBlockNeighbor().

_sub_Re

std::vector<std::vector<DenseVector<Number> > > Assembly::_sub_Re

protected

Definition at line 2648 of file Assembly.h.

Referenced by addResidual(), addResidualScalar(), cacheResidual(), prepareBlock(), prepareResidual(), prepareScalar(), prepareVariable(), residualBlock(), and setResidual().

_sub_Rl

std::vector<std::vector<DenseVector<Number> > > Assembly::_sub_Rl

protected

residual contributions for each variable from the lower dimensional element

Definition at line 2651 of file Assembly.h.

Referenced by addResidualLower(), cacheResidualLower(), prepareLowerD(), and residualBlockLower().

_sub_Rn

std::vector<std::vector<DenseVector<Number> > > Assembly::_sub_Rn

protected

Definition at line 2649 of file Assembly.h.

Referenced by addResidualNeighbor(), cacheResidualNeighbor(), prepareNeighbor(), residualBlockNeighbor(), and setResidualNeighbor().

_subproblem

SubProblem& Assembly::_subproblem

private

Definition at line 2301 of file Assembly.h.

Referenced by addCachedJacobian(), cacheResidual(), cacheResidualNodes(), computeADFace(), computeFaceMap(), computeSinglePointMapAD(), elementVolume(), reinitFE(), reinitLowerDElem(), reinitNeighborLowerDElem(), and setCoordinateTransformation().

_sys

SystemBase& Assembly::_sys

private

Definition at line 2300 of file Assembly.h.

Referenced by addCachedJacobian(), addCachedResiduals(), addJacobianBlock(), addJacobianBlockNonlocal(), addJacobianCoupledVarPair(), addJacobianLowerD(), addJacobianNeighbor(), addJacobianNeighborLowerD(), addJacobianNonlocal(), addResidual(), addResidual(), addResidualLower(), addResidualLower(), addResidualNeighbor(), addResidualNeighbor(), addResidualScalar(), addResidualScalar(), cacheJacobian(), cacheJacobianBlock(), cacheJacobianBlock(), cacheJacobianBlockNonzero(), cacheJacobianCoupledVarPair(), cacheJacobianMortar(), cacheJacobianNeighbor(), cacheJacobianNonlocal(), cacheResidual(), cacheResidualLower(), cacheResidualNeighbor(), computeFaceMap(), computeSinglePointMapAD(), copyFaceShapes(), copyNeighborShapes(), copyShapes(), initNonlocalCoupling(), prepareBlock(), prepareBlockNonlocal(), prepareLowerD(), prepareNeighbor(), prepareOffDiagScalar(), prepareResidual(), prepareScalar(), setCachedJacobian(), setResidual(), setResidualNeighbor(), and zeroCachedJacobian().

_temp_dof_indices

std::vector<dof_id_type> Assembly::_temp_dof_indices

protected

Temporary work vector to keep from reallocating it.

Definition at line 2813 of file Assembly.h.

Referenced by addResidualBlock(), and cacheResidualBlock().

_temp_reference_points

std::vector<Point> Assembly::_temp_reference_points

protected

Temporary work data for reinitAtPhysical()

Definition at line 2816 of file Assembly.h.

Referenced by reinitAtPhysical().

_tid

THREAD_ID Assembly::_tid

private

Thread number (id)

Definition at line 2338 of file Assembly.h.

Referenced by addJacobianBlockNonlocal(), addResidual(), addResidualLower(), addResidualNeighbor(), addResidualScalar(), cacheResidual(), cacheResidualLower(), cacheResidualNeighbor(), copyFaceShapes(), copyNeighborShapes(), copyShapes(), initNonlocalCoupling(), prepareBlock(), prepareBlockNonlocal(), prepareLowerD(), prepareNeighbor(), prepareOffDiagScalar(), prepareResidual(), prepareScalar(), setResidual(), and setResidualNeighbor().

_tmp_Ke

DenseMatrix<Number> Assembly::_tmp_Ke

protected

auxiliary matrix for scaling jacobians (optimization to avoid expensive construction/destruction)

Definition at line 2688 of file Assembly.h.

_tmp_Re

DenseVector<Number> Assembly::_tmp_Re

protected

auxiliary vector for scaling residuals (optimization to avoid expensive construction/destruction)

Definition at line 2654 of file Assembly.h.

Referenced by addResidualBlock(), cacheResidualBlock(), and setResidualBlock().

_unique_fe_face_helper

std::vector<std::unique_ptr<FEBase> > Assembly::_unique_fe_face_helper

private

Definition at line 2358 of file Assembly.h.

Referenced by preparePRefinement(), reinitElemFaceRef(), and reinitFEFace().

_unique_fe_face_neighbor_helper

std::vector<std::unique_ptr<FEBase> > Assembly::_unique_fe_face_neighbor_helper

private

Definition at line 2359 of file Assembly.h.

Referenced by preparePRefinement(), reinitFEFaceNeighbor(), reinitNeighborFaceRef(), and setNeighborQRule().

_unique_fe_helper

std::vector<std::unique_ptr<FEBase> > Assembly::_unique_fe_helper

private

Containers for holding unique FE helper types if we are doing p-refinement.

If we are not doing p-refinement then the helper data is owned by the _fe data members

Definition at line 2357 of file Assembly.h.

Referenced by preparePRefinement(), and reinitFE().

_unique_fe_lower_helper

std::vector<std::unique_ptr<FEBase> > Assembly::_unique_fe_lower_helper

private

Definition at line 2361 of file Assembly.h.

Referenced by preparePRefinement(), reinitLowerDElem(), and setLowerQRule().

_unique_fe_neighbor_helper

std::vector<std::unique_ptr<FEBase> > Assembly::_unique_fe_neighbor_helper

private

Definition at line 2360 of file Assembly.h.

Referenced by preparePRefinement(), and reinitFENeighbor().

_user_added_fe_face_neighbor_of_helper_type

bool Assembly::_user_added_fe_face_neighbor_of_helper_type

mutableprivate

Definition at line 2351 of file Assembly.h.

Referenced by buildFaceNeighborFE(), and preparePRefinement().

_user_added_fe_face_of_helper_type

bool Assembly::_user_added_fe_face_of_helper_type

mutableprivate

Definition at line 2350 of file Assembly.h.

Referenced by buildFaceFE(), and preparePRefinement().

_user_added_fe_lower_of_helper_type

bool Assembly::_user_added_fe_lower_of_helper_type

mutableprivate

Definition at line 2353 of file Assembly.h.

Referenced by buildLowerDFE(), and preparePRefinement().

_user_added_fe_neighbor_of_helper_type

bool Assembly::_user_added_fe_neighbor_of_helper_type

mutableprivate

Definition at line 2352 of file Assembly.h.

Referenced by buildNeighborFE(), and preparePRefinement().

_user_added_fe_of_helper_type

bool Assembly::_user_added_fe_of_helper_type

mutableprivate

Whether user code requested a FEType the same as our _helper_type.

Definition at line 2349 of file Assembly.h.

Referenced by buildFE(), and preparePRefinement().

_vector_curl_phi

VectorVariablePhiCurl Assembly::_vector_curl_phi

protected

Definition at line 2711 of file Assembly.h.

Referenced by curlPhi(), and curlPhi().

_vector_curl_phi_face

VectorVariablePhiCurl Assembly::_vector_curl_phi_face

protected

Definition at line 2717 of file Assembly.h.

Referenced by copyFaceShapes(), curlPhiFace(), and curlPhiFace().

_vector_curl_phi_face_neighbor

VectorVariablePhiCurl Assembly::_vector_curl_phi_face_neighbor

protected

Definition at line 2729 of file Assembly.h.

Referenced by curlPhiFaceNeighbor(), and curlPhiFaceNeighbor().

_vector_curl_phi_neighbor

VectorVariablePhiCurl Assembly::_vector_curl_phi_neighbor

protected

Definition at line 2723 of file Assembly.h.

Referenced by curlPhiNeighbor(), and curlPhiNeighbor().

_vector_div_phi

VectorVariablePhiDivergence Assembly::_vector_div_phi

protected

Definition at line 2712 of file Assembly.h.

Referenced by divPhi(), and divPhi().

_vector_div_phi_face

VectorVariablePhiDivergence Assembly::_vector_div_phi_face

protected

Definition at line 2718 of file Assembly.h.

Referenced by copyFaceShapes(), divPhiFace(), and divPhiFace().

_vector_div_phi_face_neighbor

VectorVariablePhiDivergence Assembly::_vector_div_phi_face_neighbor

protected

Definition at line 2730 of file Assembly.h.

Referenced by divPhiFaceNeighbor(), and divPhiFaceNeighbor().

_vector_div_phi_neighbor

VectorVariablePhiDivergence Assembly::_vector_div_phi_neighbor

protected

Definition at line 2724 of file Assembly.h.

Referenced by divPhiNeighbor(), and divPhiNeighbor().

_vector_fe

std::map<unsigned int, std::map<FEType, FEVectorBase *> > Assembly::_vector_fe

mutableprivate

Each dimension's actual vector fe objects indexed on type.

Definition at line 2392 of file Assembly.h.

Referenced by buildVectorFE(), getVectorFE(), reinitFE(), and ~Assembly().

_vector_fe_face

std::map<unsigned int, std::map<FEType, FEVectorBase *> > Assembly::_vector_fe_face

mutableprivate

types of vector finite elements

Definition at line 2504 of file Assembly.h.

Referenced by buildVectorFaceFE(), computeADFace(), getVectorFEFace(), reinitElemFaceRef(), reinitFEFace(), and ~Assembly().

_vector_fe_face_neighbor

std::map<unsigned int, std::map<FEType, FEVectorBase *> > Assembly::_vector_fe_face_neighbor

mutableprivate

Definition at line 2537 of file Assembly.h.

Referenced by buildVectorFaceNeighborFE(), getVectorFEFaceNeighbor(), reinitFEFaceNeighbor(), reinitNeighborFaceRef(), setNeighborQRule(), and ~Assembly().

_vector_fe_lower

std::map<unsigned int, std::map<FEType, FEVectorBase *> > Assembly::_vector_fe_lower

mutableprivate

Vector FE objects for lower dimensional elements.

Definition at line 2546 of file Assembly.h.

Referenced by buildVectorDualLowerDFE(), buildVectorLowerDFE(), setLowerQRule(), and ~Assembly().

_vector_fe_neighbor

std::map<unsigned int, std::map<FEType, FEVectorBase *> > Assembly::_vector_fe_neighbor

mutableprivate

Definition at line 2536 of file Assembly.h.

Referenced by buildVectorNeighborFE(), getVectorFENeighbor(), reinitFENeighbor(), and ~Assembly().

_vector_fe_shape_data

std::map<FEType, std::unique_ptr<VectorFEShapeData> > Assembly::_vector_fe_shape_data

mutableprotected

Shape function values, gradients, second derivatives for each vector FE type.

Definition at line 2761 of file Assembly.h.

Referenced by buildVectorFE(), and reinitFE().

_vector_fe_shape_data_dual_lower

std::map<FEType, std::unique_ptr<VectorFEShapeData> > Assembly::_vector_fe_shape_data_dual_lower

mutableprotected

Definition at line 2766 of file Assembly.h.

Referenced by buildVectorDualLowerDFE().

_vector_fe_shape_data_face

std::map<FEType, std::unique_ptr<VectorFEShapeData> > Assembly::_vector_fe_shape_data_face

mutableprotected

Definition at line 2762 of file Assembly.h.

Referenced by buildVectorFaceFE(), computeADFace(), reinitElemFaceRef(), and reinitFEFace().

_vector_fe_shape_data_face_neighbor

std::map<FEType, std::unique_ptr<VectorFEShapeData> > Assembly::_vector_fe_shape_data_face_neighbor

mutableprotected

Definition at line 2764 of file Assembly.h.

Referenced by buildVectorFaceNeighborFE(), reinitFEFaceNeighbor(), and reinitNeighborFaceRef().

_vector_fe_shape_data_lower

std::map<FEType, std::unique_ptr<VectorFEShapeData> > Assembly::_vector_fe_shape_data_lower

mutableprotected

Definition at line 2765 of file Assembly.h.

Referenced by buildVectorLowerDFE().

_vector_fe_shape_data_neighbor

std::map<FEType, std::unique_ptr<VectorFEShapeData> > Assembly::_vector_fe_shape_data_neighbor

mutableprotected

Definition at line 2763 of file Assembly.h.

Referenced by buildVectorNeighborFE(), and reinitFENeighbor().

_vector_grad_phi

VectorVariablePhiGradient Assembly::_vector_grad_phi

protected

Definition at line 2709 of file Assembly.h.

Referenced by gradPhi(), and gradPhi().

_vector_grad_phi_face

VectorVariablePhiGradient Assembly::_vector_grad_phi_face

protected

Definition at line 2715 of file Assembly.h.

Referenced by gradPhiFace(), and gradPhiFace().

_vector_grad_phi_face_neighbor

VectorVariablePhiGradient Assembly::_vector_grad_phi_face_neighbor

protected

Definition at line 2727 of file Assembly.h.

Referenced by gradPhiFaceNeighbor(), and gradPhiFaceNeighbor().

_vector_grad_phi_neighbor

VectorVariablePhiGradient Assembly::_vector_grad_phi_neighbor

protected

Definition at line 2721 of file Assembly.h.

Referenced by gradPhiNeighbor(), and gradPhiNeighbor().

_vector_phi

VectorVariablePhiValue Assembly::_vector_phi

protected

Definition at line 2708 of file Assembly.h.

Referenced by phi(), and phi().

_vector_phi_face

VectorVariablePhiValue Assembly::_vector_phi_face

protected

Definition at line 2714 of file Assembly.h.

Referenced by phiFace(), and phiFace().

_vector_phi_face_neighbor

VectorVariablePhiValue Assembly::_vector_phi_face_neighbor

protected

Definition at line 2726 of file Assembly.h.

Referenced by phiFaceNeighbor(), and phiFaceNeighbor().

_vector_phi_neighbor

VectorVariablePhiValue Assembly::_vector_phi_neighbor

protected

Definition at line 2720 of file Assembly.h.

Referenced by phiNeighbor(), and phiNeighbor().

_vector_second_phi

VectorVariablePhiSecond Assembly::_vector_second_phi

protected

Definition at line 2710 of file Assembly.h.

Referenced by secondPhi(), and secondPhi().

_vector_second_phi_face

VectorVariablePhiSecond Assembly::_vector_second_phi_face

protected

Definition at line 2716 of file Assembly.h.

Referenced by secondPhiFace(), and secondPhiFace().

_vector_second_phi_face_neighbor

VectorVariablePhiSecond Assembly::_vector_second_phi_face_neighbor

protected

Definition at line 2728 of file Assembly.h.

Referenced by secondPhiFaceNeighbor(), and secondPhiFaceNeighbor().

_vector_second_phi_neighbor

VectorVariablePhiSecond Assembly::_vector_second_phi_neighbor

protected

Definition at line 2722 of file Assembly.h.

Referenced by secondPhiNeighbor(), and secondPhiNeighbor().

_xfem

std::shared_ptr<XFEMInterface> Assembly::_xfem

private

The XFEM controller.

Definition at line 2367 of file Assembly.h.

Referenced by modifyFaceWeightsDueToXFEM(), modifyWeightsDueToXFEM(), reinitFE(), reinitFEFace(), and setXFEM().

---

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

• include/base/Assembly.h
• src/base/Assembly.C