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
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	hasScalingVector ()
	signals this object that a vector containing variable scaling factors should be used when doing residual and matrix assembly
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	havePRefinement (const std::unordered_set< FEFamily > &disable_p_refinement_for_families)
	Indicate that we have 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<>
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
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
const NumericVector< Real > *	_scaling_vector = nullptr
	The map from global index to variable scaling factor.
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	_have_p_refinement
	Whether we have ever conducted 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 109 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 228 of file Assembly.h.

Constructor & Destructor Documentation

Assembly()

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

Definition at line 81 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(_mesh.hasSecondOrderElements() ? SECOND : FIRST, LAGRANGE),
    _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),
    _have_p_refinement(false)
{
  const Order helper_order = _mesh.hasSecondOrderElements() ? SECOND : FIRST;
  _building_helpers = true;
  // Build fe's for the helpers
  buildFE(FEType(helper_order, LAGRANGE));
  buildFaceFE(FEType(helper_order, LAGRANGE));
  buildNeighborFE(FEType(helper_order, LAGRANGE));
  buildFaceNeighborFE(FEType(helper_order, LAGRANGE));
  buildLowerDFE(FEType(helper_order, LAGRANGE));
  _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][FEType(helper_order, LAGRANGE)];
    _holder_fe_face_helper[dim] = _fe_face[dim][FEType(helper_order, LAGRANGE)];
    _holder_fe_face_neighbor_helper[dim] = _fe_face_neighbor[dim][FEType(helper_order, LAGRANGE)];
    _holder_fe_neighbor_helper[dim] = _fe_neighbor[dim][FEType(helper_order, LAGRANGE)];
  }
 
  for (unsigned int dim = 0; dim < _mesh_dimension; dim++)
    _holder_fe_lower_helper[dim] = _fe_lower[dim][FEType(helper_order, LAGRANGE)];
 
  // 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
  _fe_msm = (_mesh_dimension == 2)
                ? FEGenericBase<Real>::build(_mesh_dimension - 1, FEType(helper_order, LAGRANGE))
                : FEGenericBase<Real>::build(_mesh_dimension - 1, FEType(FIRST, LAGRANGE));
  // 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 188 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 617 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 300 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 4798 of file Assembly.C.

{
  _calculate_curvatures = true;
  const Order helper_order = _mesh.hasSecondOrderElements() ? SECOND : FIRST;
  const FEType helper_type(helper_order, LAGRANGE);
  // 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 3800 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 3515 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 3470 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 3857 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.

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 4283 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 4341 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 4215 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 3842 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 4008 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 3892 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 3930 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 4425 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 3870 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 4447 of file Assembly.C.

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

addJacobianScalar()

void Assembly::addJacobianScalar

(

GlobalDataKey

)

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

Definition at line 4440 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 3304 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 3317 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 3251 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 3347 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 3361 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 3325 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 3339 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 3370 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 3384 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 3051 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 1322 of file Assembly.h.

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

adJxW()

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

inline

Definition at line 278 of file Assembly.h.

{ return _ad_JxW; }

adJxWFace()

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

inline

Definition at line 280 of file Assembly.h.

{ return _ad_JxW_face; }

adNormals()

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

inline

Definition at line 393 of file Assembly.h.

{ return _ad_normals; }

adQPoints()

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

inline

Definition at line 395 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 401 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 3221 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 1908 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 1920 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 294 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]->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 338 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]->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 268 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]->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 384 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]->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 360 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]->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 316 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]->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 430 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]->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 486 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]->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 546 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]->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 455 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]->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 405 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]->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 516 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]->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 600 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 577 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 3117 of file Assembly.h.

{
  if (!computingJacobian() || matrix_tags.empty())
    return;
 
  if (residuals.size() == 1)
  {
    // 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 4045 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 4465 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 4456 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 3606 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 : 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 3721 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 3665 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 : 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 4059 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 4135 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 4097 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 4075 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 3179 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 3417 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 3407 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 3392 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 3266 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 3456 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 3442 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 3424 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 3059 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;
 
  if (residuals.size() == 1)
  {
    // 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 3099 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 4507 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 728 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 3493 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 3485 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 2113 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];
    }
 
    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 1756 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 1775 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().

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 1350 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 =
          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 =
          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 893 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 1003 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();
  auto num_shapes = FEInterface::n_shape_functions(fe->get_fe_type(), elem);
  const auto & phi_map = fe->get_fe_map().get_phi_map();
  const auto & dphidxi_map = fe->get_fe_map().get_dphidxi_map();
  const auto & dphideta_map = fe->get_fe_map().get_dphideta_map();
  const auto & dphidzeta_map = fe->get_fe_map().get_dphidzeta_map();
  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 1951 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 1946 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 1956 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 120 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 316 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 288 of file Assembly.h.

{ return _coord; }

copyFaceShapes() [1/2]

template<typename T >

void Assembly::copyFaceShapes

(

MooseVariableField< T > &

v

)

Definition at line 3040 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 3049 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 3077 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 3097 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 3003 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 3012 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 1294 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 1299 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 619 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(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 1506 of file Assembly.h.

  {
    return _vector_curl_phi;
  }

curlPhi() [2/2]

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

inline

Definition at line 1385 of file Assembly.h.

  {
    return _vector_curl_phi;
  }

Referenced by copyShapes().

curlPhiFace() [1/2]

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

inline

Definition at line 1527 of file Assembly.h.

  {
    return _vector_curl_phi_face;
  }

curlPhiFace() [2/2]

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

inline

Definition at line 1406 of file Assembly.h.

  {
    return _vector_curl_phi_face;
  }

curlPhiFaceNeighbor() [1/2]

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

inline

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

  {
    return _vector_curl_phi_face_neighbor;
  }

curlPhiNeighbor() [1/2]

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

inline

Definition at line 1548 of file Assembly.h.

  {
    return _vector_curl_phi_neighbor;
  }

curlPhiNeighbor() [2/2]

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

inline

Definition at line 1429 of file Assembly.h.

  {
    return _vector_curl_phi_neighbor;
  }

currentBoundaryID()

const BoundaryID & Assembly::currentBoundaryID ( ) const

inline

Return the current boundary ID.

Definition at line 429 of file Assembly.h.

{ return _current_boundary_id; }

currentNeighborSubdomainID()

const SubdomainID & Assembly::currentNeighborSubdomainID ( ) const

inline

Return the current subdomain ID.

Definition at line 497 of file Assembly.h.

{ return _current_neighbor_subdomain_id; }

currentSubdomainID()

const SubdomainID & Assembly::currentSubdomainID ( ) const

inline

Return the current subdomain ID.

Definition at line 419 of file Assembly.h.

{ return _current_subdomain_id; }

divPhi() [1/2]

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

inline

Definition at line 1510 of file Assembly.h.

  {
    return _vector_div_phi;
  }

divPhi() [2/2]

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

inline

Definition at line 1389 of file Assembly.h.

  {
    return _vector_div_phi;
  }

Referenced by copyShapes().

divPhiFace() [1/2]

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

inline

Definition at line 1531 of file Assembly.h.

  {
    return _vector_div_phi_face;
  }

divPhiFace() [2/2]

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

inline

Definition at line 1410 of file Assembly.h.

  {
    return _vector_div_phi_face;
  }

divPhiFaceNeighbor() [1/2]

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

inline

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

  {
    return _vector_div_phi_face_neighbor;
  }

divPhiNeighbor() [1/2]

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

inline

Definition at line 1552 of file Assembly.h.

  {
    return _vector_div_phi_neighbor;
  }

divPhiNeighbor() [2/2]

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

inline

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

{ return _current_elem; }

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

elementVolume()

Real Assembly::elementVolume

(

const Elem *

elem

)

const

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

Definition at line 3757 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 reinitLowerDElem(), and reinitNeighborLowerDElem().

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 440 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 378 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 387 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 1633 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 2941 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 1674 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 2948 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 1734 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 4713 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 1742 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 4722 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 1758 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 4746 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 1750 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 4737 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 1766 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 4756 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 1773 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 4765 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 1789 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 4789 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 1781 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 4780 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 2918 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 4608 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 2934 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 4624 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 1626 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 4583 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 1667 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 4640 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 1718 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 4696 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 2926 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 4616 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 1695 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 4671 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 1619 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 4575 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 1660 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 4632 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 1710 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 4688 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 2910 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 4600 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 1688 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 4663 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 1639 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 4591 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 1680 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 4648 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 1726 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 4704 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 1702 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 4679 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 1309 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 4956 of file Assembly.C.

{
  return qPoints();
}

genericQPoints() [3/3]

template<>

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

(

)

const

Definition at line 4963 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 132 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 156 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 168 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 144 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 1892 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 180 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 204 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 216 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 192 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 1327 of file Assembly.h.

{ return _grad_phi; }

Referenced by copyShapes().

gradPhi() [2/6]

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

inline

Definition at line 1466 of file Assembly.h.

{ return _grad_phi; }

gradPhi() [3/6]

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

inline

Definition at line 1328 of file Assembly.h.

{ return _grad_phi; }

gradPhi() [4/6]

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

inline

Definition at line 1579 of file Assembly.h.

{ return _grad_phi; }

gradPhi() [5/6]

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

inline

Definition at line 1498 of file Assembly.h.

  {
    return _vector_grad_phi;
  }

gradPhi() [6/6]

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

inline

Definition at line 1377 of file Assembly.h.

  {
    return _vector_grad_phi;
  }

gradPhiFace() [1/6]

const VariablePhiGradient & Assembly::gradPhiFace ( ) const

inline

Definition at line 1337 of file Assembly.h.

{ return _grad_phi_face; }

Referenced by copyFaceShapes().

gradPhiFace() [2/6]

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

inline

Definition at line 1470 of file Assembly.h.

{ return _grad_phi_face; }

gradPhiFace() [3/6]

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

inline

Definition at line 1338 of file Assembly.h.

  {
    return _grad_phi_face;
  }

gradPhiFace() [4/6]

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

inline

Definition at line 1583 of file Assembly.h.

  {
    return _grad_phi_face;
  }

gradPhiFace() [5/6]

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

inline

Definition at line 1519 of file Assembly.h.

  {
    return _vector_grad_phi_face;
  }

gradPhiFace() [6/6]

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

inline

Definition at line 1398 of file Assembly.h.

  {
    return _vector_grad_phi_face;
  }

gradPhiFaceNeighbor() [1/5]

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

inline

Definition at line 1487 of file Assembly.h.

  {
    return _grad_phi_face_neighbor;
  }

gradPhiFaceNeighbor() [2/5]

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

inline

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

  {
    return _grad_phi_face_neighbor;
  }

gradPhiFaceNeighbor() [4/5]

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

inline

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

  {
    return _vector_grad_phi_face_neighbor;
  }

gradPhiNeighbor() [1/5]

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

inline

Definition at line 1474 of file Assembly.h.

  {
    return _grad_phi_neighbor;
  }

gradPhiNeighbor() [2/5]

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

inline

Definition at line 1351 of file Assembly.h.

  {
    return _grad_phi_neighbor;
  }

Referenced by copyNeighborShapes().

gradPhiNeighbor() [3/5]

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

inline

Definition at line 1596 of file Assembly.h.

  {
    return _grad_phi_neighbor;
  }

gradPhiNeighbor() [4/5]

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

inline

Definition at line 1540 of file Assembly.h.

  {
    return _vector_grad_phi_neighbor;
  }

gradPhiNeighbor() [5/5]

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

inline

Definition at line 1420 of file Assembly.h.

  {
    return _vector_grad_phi_neighbor;
  }

hasScalingVector()

void Assembly::hasScalingVector

(

)

signals this object that a vector containing variable scaling factors should be used when doing residual and matrix assembly

Definition at line 4559 of file Assembly.C.

{
  _scaling_vector = &_sys.getVector("scaling_factors");
}

Referenced by SubProblem::hasScalingVector().

havePRefinement()

void Assembly::havePRefinement

(

const std::unordered_set< FEFamily > &

disable_p_refinement_for_families

)

Indicate that we have p-refinement.

This method will perform the following tasks:

• Disable p-refinement as requested by the user with disable_p_refinement_for_families -.Disable p-refinement of Lagrange helper types that we use for getting things like the physical locations of quadrature points and JxW. (Don't worry, we still use the element p-level when initializing the quadrature rule attached to the Lagrange helper so the number of quadrature points reflects the element p-level)

  Parameters

  disable_p_refinement_for_families

  Families that we should disable p-refinement for

Definition at line 4844 of file Assembly.C.

{
  if (_have_p_refinement)
    // Already performed tasks for p-refinement
    return;
 
  const Order helper_order = _mesh.hasSecondOrderElements() ? SECOND : FIRST;
  const FEType helper_type(helper_order, LAGRANGE);
  auto process_fe =
      [&disable_families](const unsigned int num_dimensionalities, auto & fe_container)
  {
    if (!disable_families.empty())
      for (const auto dim : make_range(num_dimensionalities))
      {
        auto fe_container_it = fe_container.find(dim);
        if (fe_container_it != fe_container.end())
          for (auto & [fe_type, fe_ptr] : fe_container_it->second)
            if (disable_families.count(fe_type.family))
              fe_ptr->add_p_level_in_reinit(false);
      }
  };
  auto process_fe_and_helpers = [process_fe, &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 it from our FE container
      // so that they're not penalized (in the "we should be able to do p-refinement sense") for
      // our perhaps silly helpers
      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);
      }
    }
 
    process_fe(num_dimensionalities, fe_container);
  };
 
  // 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);
  // Handle vector field families
  process_fe(_mesh_dimension + 1, _vector_fe);
  process_fe(_mesh_dimension + 1, _vector_fe_face);
  process_fe(_mesh_dimension + 1, _vector_fe_neighbor);
  process_fe(_mesh_dimension + 1, _vector_fe_face_neighbor);
  process_fe(_mesh_dimension, _vector_fe_lower);
 
  helpersRequestData();
 
  _have_p_refinement = true;
}

Referenced by SubProblem::preparePRefinement().

helpersRequestData()

void Assembly::helpersRequestData ( )

private

request phi, dphi, xyz, JxW, etc.

data through the FE helper functions

Definition at line 4811 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 havePRefinement().

init()

void Assembly::init

(

const libMesh::CouplingMatrix *

cm

)

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

Definition at line 2469 of file Assembly.C.

{
  _cm = cm;
 
  unsigned int n_vars = _sys.nVariables();
 
  _cm_ss_entry.clear();
  _cm_sf_entry.clear();
  _cm_fs_entry.clear();
  _cm_ff_entry.clear();
 
  auto & vars = _sys.getVariables(_tid);
 
  _block_diagonal_matrix = true;
  for (auto & ivar : vars)
  {
    auto i = ivar->number();
    if (i >= _component_block_diagonal.size())
      _component_block_diagonal.resize(i + 1, true);
 
    auto ivar_start = _cm_ff_entry.size();
    for (unsigned int k = 0; k < ivar->count(); ++k)
    {
      unsigned int iv = i + k;
      for (const auto & j : ConstCouplingRow(iv, *_cm))
      {
        if (_sys.isScalarVariable(j))
        {
          auto & jvar = _sys.getScalarVariable(_tid, j);
          _cm_fs_entry.push_back(std::make_pair(ivar, &jvar));
          _block_diagonal_matrix = false;
        }
        else
        {
          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_ff_entry.size(); ++c)
            if (_cm_ff_entry[c] == pair)
            {
              has_pair = true;
              break;
            }
          if (!has_pair)
            _cm_ff_entry.push_back(pair);
          // only set having diagonal matrix to false when ivar and jvar numbers are different
          // Note: for array variables, since we save the entire local Jacobian of all components,
          //       even there are couplings among components of the same array variable, we still
          //       do not set the flag to false.
          if (i != jvar.number())
            _block_diagonal_matrix = false;
          else if (iv != j)
            _component_block_diagonal[i] = false;
        }
      }
    }
  }
 
  auto & scalar_vars = _sys.getScalarVariables(_tid);
 
  for (auto & ivar : scalar_vars)
  {
    auto i = ivar->number();
    if (i >= _component_block_diagonal.size())
      _component_block_diagonal.resize(i + 1, true);
 
    for (const auto & j : ConstCouplingRow(i, *_cm))
      if (_sys.isScalarVariable(j))
      {
        auto & jvar = _sys.getScalarVariable(_tid, j);
        _cm_ss_entry.push_back(std::make_pair(ivar, &jvar));
      }
      else
      {
        auto & jvar = _sys.getVariable(_tid, j);
        _cm_sf_entry.push_back(std::make_pair(ivar, &jvar));
      }
  }
 
  if (_block_diagonal_matrix && scalar_vars.size() != 0)
    _block_diagonal_matrix = false;
 
  auto num_vector_tags = _residual_vector_tags.size();
 
  _sub_Re.resize(num_vector_tags);
  _sub_Rn.resize(num_vector_tags);
  _sub_Rl.resize(num_vector_tags);
  for (MooseIndex(_sub_Re) i = 0; i < _sub_Re.size(); i++)
  {
    _sub_Re[i].resize(n_vars);
    _sub_Rn[i].resize(n_vars);
    _sub_Rl[i].resize(n_vars);
  }
 
  _cached_residual_values.resize(num_vector_tags);
  _cached_residual_rows.resize(num_vector_tags);
 
  auto num_matrix_tags = _subproblem.numMatrixTags();
 
  _cached_jacobian_values.resize(num_matrix_tags);
  _cached_jacobian_rows.resize(num_matrix_tags);
  _cached_jacobian_cols.resize(num_matrix_tags);
 
  // Element matrices
  _sub_Kee.resize(num_matrix_tags);
  _sub_Keg.resize(num_matrix_tags);
  _sub_Ken.resize(num_matrix_tags);
  _sub_Kne.resize(num_matrix_tags);
  _sub_Knn.resize(num_matrix_tags);
  _sub_Kll.resize(num_matrix_tags);
  _sub_Kle.resize(num_matrix_tags);
  _sub_Kln.resize(num_matrix_tags);
  _sub_Kel.resize(num_matrix_tags);
  _sub_Knl.resize(num_matrix_tags);
 
  _jacobian_block_used.resize(num_matrix_tags);
  _jacobian_block_neighbor_used.resize(num_matrix_tags);
  _jacobian_block_lower_used.resize(num_matrix_tags);
  _jacobian_block_nonlocal_used.resize(num_matrix_tags);
 
  for (MooseIndex(num_matrix_tags) tag = 0; tag < num_matrix_tags; tag++)
  {
    _sub_Keg[tag].resize(n_vars);
    _sub_Ken[tag].resize(n_vars);
    _sub_Kne[tag].resize(n_vars);
    _sub_Knn[tag].resize(n_vars);
    _sub_Kee[tag].resize(n_vars);
    _sub_Kll[tag].resize(n_vars);
    _sub_Kle[tag].resize(n_vars);
    _sub_Kln[tag].resize(n_vars);
    _sub_Kel[tag].resize(n_vars);
    _sub_Knl[tag].resize(n_vars);
 
    _jacobian_block_used[tag].resize(n_vars);
    _jacobian_block_neighbor_used[tag].resize(n_vars);
    _jacobian_block_lower_used[tag].resize(n_vars);
    _jacobian_block_nonlocal_used[tag].resize(n_vars);
    for (MooseIndex(n_vars) i = 0; i < n_vars; ++i)
    {
      if (!_block_diagonal_matrix)
      {
        _sub_Kee[tag][i].resize(n_vars);
        _sub_Keg[tag][i].resize(n_vars);
        _sub_Ken[tag][i].resize(n_vars);
        _sub_Kne[tag][i].resize(n_vars);
        _sub_Knn[tag][i].resize(n_vars);
        _sub_Kll[tag][i].resize(n_vars);
        _sub_Kle[tag][i].resize(n_vars);
        _sub_Kln[tag][i].resize(n_vars);
        _sub_Kel[tag][i].resize(n_vars);
        _sub_Knl[tag][i].resize(n_vars);
 
        _jacobian_block_used[tag][i].resize(n_vars);
        _jacobian_block_neighbor_used[tag][i].resize(n_vars);
        _jacobian_block_lower_used[tag][i].resize(n_vars);
        _jacobian_block_nonlocal_used[tag][i].resize(n_vars);
      }
      else
      {
        _sub_Kee[tag][i].resize(1);
        _sub_Keg[tag][i].resize(1);
        _sub_Ken[tag][i].resize(1);
        _sub_Kne[tag][i].resize(1);
        _sub_Knn[tag][i].resize(1);
        _sub_Kll[tag][i].resize(1);
        _sub_Kle[tag][i].resize(1);
        _sub_Kln[tag][i].resize(1);
        _sub_Kel[tag][i].resize(1);
        _sub_Knl[tag][i].resize(1);
 
        _jacobian_block_used[tag][i].resize(1);
        _jacobian_block_neighbor_used[tag][i].resize(1);
        _jacobian_block_lower_used[tag][i].resize(1);
        _jacobian_block_nonlocal_used[tag][i].resize(1);
      }
    }
  }
}

initNonlocalCoupling()

void Assembly::initNonlocalCoupling

(

)

Create pair of variables requiring nonlocal jacobian contributions.

Definition at line 2651 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 : 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 1142 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 2285 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 2276 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 3161 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 3120 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(), FVInterfaceKernel::addJacobian(), addJacobianNeighbor(), addJacobianNeighborLowerD(), cacheJacobianNeighbor(), 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 2267 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 2258 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 1153 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 2303 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 2294 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 2249 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 2240 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 276 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 351 of file Assembly.h.

{ return _current_JxW_face; }

jxWMortar()

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

inline

Returns a reference to JxW for mortar segment elements.

Definition at line 707 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 261 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 476 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 3207 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 362 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 4565 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 4538 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 4518 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 294 of file Assembly.h.

{ return _coord_msm; }

msmElem()

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

inline

Returns

The current mortar segment element

Definition at line 1961 of file Assembly.h.

{ return _msm_elem; }

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

{ return _current_neighbor_elem; }

Referenced by Moose::globalDofIndexToDerivative(), MooseVariableFE< OutputType >::MooseVariableFE(), 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 482 of file Assembly.h.

{ return _current_neighbor_lower_d_elem; }

neighborLowerDElemVolume()

const Real & Assembly::neighborLowerDElemVolume ( ) const

inline

Definition at line 3214 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 452 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 508 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 545 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 551 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 1304 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 357 of file Assembly.h.

{ return _current_normals; }

numExtraElemIntegers()

unsigned int Assembly::numExtraElemIntegers ( ) const

inline

Number of extra element integers Assembly tracked.

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

{ return _phi; }

Referenced by copyShapes().

phi() [2/6]

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

inline

Definition at line 1465 of file Assembly.h.

{ return _phi; }

phi() [3/6]

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

inline

Definition at line 1326 of file Assembly.h.

{ return _phi; }

phi() [4/6]

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

inline

Definition at line 1578 of file Assembly.h.

{ return _phi; }

phi() [5/6]

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

inline

Definition at line 1497 of file Assembly.h.

{ return _vector_phi; }

phi() [6/6]

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

inline

Definition at line 1373 of file Assembly.h.

  {
    return _vector_phi;
  }

phiFace() [1/6]

const VariablePhiValue & Assembly::phiFace ( ) const

inline

Definition at line 1335 of file Assembly.h.

{ return _phi_face; }

Referenced by copyFaceShapes().

phiFace() [2/6]

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

inline

Definition at line 1469 of file Assembly.h.

{ return _phi_face; }

phiFace() [3/6]

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

inline

Definition at line 1336 of file Assembly.h.

{ return _phi_face; }

phiFace() [4/6]

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

inline

Definition at line 1582 of file Assembly.h.

{ return _phi_face; }

phiFace() [5/6]

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

inline

Definition at line 1515 of file Assembly.h.

  {
    return _vector_phi_face;
  }

phiFace() [6/6]

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

inline

Definition at line 1394 of file Assembly.h.

  {
    return _vector_phi_face;
  }

phiFaceNeighbor() [1/5]

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

inline

Definition at line 1483 of file Assembly.h.

  {
    return _phi_face_neighbor;
  }

phiFaceNeighbor() [2/5]

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

inline

Definition at line 1360 of file Assembly.h.

  {
    return _phi_face_neighbor;
  }

Referenced by copyNeighborShapes().

phiFaceNeighbor() [3/5]

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

inline

Definition at line 1605 of file Assembly.h.

  {
    return _phi_face_neighbor;
  }

phiFaceNeighbor() [4/5]

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

inline

Definition at line 1556 of file Assembly.h.

  {
    return _vector_phi_face_neighbor;
  }

phiFaceNeighbor() [5/5]

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

inline

Definition at line 1439 of file Assembly.h.

  {
    return _vector_phi_face_neighbor;
  }

phiNeighbor() [1/5]

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

inline

Definition at line 1473 of file Assembly.h.

{ return _phi_neighbor; }

phiNeighbor() [2/5]

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

inline

Definition at line 1347 of file Assembly.h.

  {
    return _phi_neighbor;
  }

Referenced by copyNeighborShapes().

phiNeighbor() [3/5]

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

inline

Definition at line 1592 of file Assembly.h.

  {
    return _phi_neighbor;
  }

phiNeighbor() [4/5]

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

inline

Definition at line 1536 of file Assembly.h.

  {
    return _vector_phi_neighbor;
  }

phiNeighbor() [5/5]

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

inline

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

{ return _current_physical_points; }

prepare()

void Assembly::prepare

(

)

Definition at line 2719 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 2902 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 2927 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 2686 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 2850 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 2812 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 2726 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 2977 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().

prepareResidual()

void Assembly::prepareResidual

(

)

Sizes and zeroes the residual for the current element.

Definition at line 2710 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 2953 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 2752 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 2782 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 3221 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 258 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 345 of file Assembly.h.

{ return _current_q_points_face; }

Referenced by GeometricSearchData::generateQuadratureNodes(), 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 539 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 264 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 235 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 1925 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 322 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 1919 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 2472 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 712 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 518 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 2491 of file Assembly.h.

{ return qrules(dim, _current_subdomain_id); }

Referenced by attachQRuleElem(), attachQRuleFace(), qruleFaceHelper(), qrules(), reinit(), reinitFVFace(), reinitLowerDElem(), reinitNeighbor(), reinitNeighborFaceRef(), 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 2496 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 1821 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 1835 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.

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 1961 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 1989 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 1794 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 2274 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 & it : _fe_lower[elem_dim])
  {
    FEBase & fe_lower = *it.second;
    // 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 1996 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 2021 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);
}

Referenced by 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 762 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 1270 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().

reinitFEFaceNeighbor()

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

private

Definition at line 1575 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 1634 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 1859 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 2292 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 2406 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 1689 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 2456 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 2420 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 2196 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 2385 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 1115 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 1133 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 1124 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 973 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 1841 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 1866 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 3790 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 1817 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 1314 of file Assembly.h.

  {
    return _cm_sf_entry;
  }

Referenced by MortarScalarBase::computeScalarOffDiagJacobian().

secondPhi() [1/6]

const VariablePhiSecond & Assembly::secondPhi ( ) const

inline

Definition at line 1329 of file Assembly.h.

{ return _second_phi; }

Referenced by copyShapes().

secondPhi() [2/6]

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

inline

Definition at line 1467 of file Assembly.h.

{ return _second_phi; }

secondPhi() [3/6]

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

inline

Definition at line 1330 of file Assembly.h.

  {
    return _second_phi;
  }

secondPhi() [4/6]

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

inline

Definition at line 1580 of file Assembly.h.

{ return _second_phi; }

secondPhi() [5/6]

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

inline

Definition at line 1502 of file Assembly.h.

  {
    return _vector_second_phi;
  }

secondPhi() [6/6]

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

inline

Definition at line 1381 of file Assembly.h.

  {
    return _vector_second_phi;
  }

secondPhiFace() [1/5]

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

inline

Definition at line 1471 of file Assembly.h.

{ return _second_phi_face; }

secondPhiFace() [2/5]

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

inline

Definition at line 1342 of file Assembly.h.

  {
    return _second_phi_face;
  }

Referenced by copyFaceShapes().

secondPhiFace() [3/5]

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

inline

Definition at line 1587 of file Assembly.h.

  {
    return _second_phi_face;
  }

secondPhiFace() [4/5]

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

inline

Definition at line 1523 of file Assembly.h.

  {
    return _vector_second_phi_face;
  }

secondPhiFace() [5/5]

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

inline

Definition at line 1402 of file Assembly.h.

  {
    return _vector_second_phi_face;
  }

secondPhiFaceNeighbor() [1/5]

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

inline

Definition at line 1491 of file Assembly.h.

  {
    return _second_phi_face_neighbor;
  }

secondPhiFaceNeighbor() [2/5]

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

inline

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

  {
    return _second_phi_face_neighbor;
  }

secondPhiFaceNeighbor() [4/5]

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

inline

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

  {
    return _vector_second_phi_face_neighbor;
  }

secondPhiNeighbor() [1/5]

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

inline

Definition at line 1478 of file Assembly.h.

  {
    return _second_phi_neighbor;
  }

secondPhiNeighbor() [2/5]

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

inline

Definition at line 1355 of file Assembly.h.

  {
    return _second_phi_neighbor;
  }

Referenced by copyNeighborShapes().

secondPhiNeighbor() [3/5]

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

inline

Definition at line 1600 of file Assembly.h.

  {
    return _second_phi_neighbor;
  }

secondPhiNeighbor() [4/5]

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

inline

Definition at line 1544 of file Assembly.h.

  {
    return _vector_second_phi_neighbor;
  }

secondPhiNeighbor() [5/5]

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

inline

Definition at line 1425 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 4477 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()

template<typename Points , typename Coords >

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

private

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

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

setCurrentBoundaryID()

void Assembly::setCurrentBoundaryID ( BoundaryID  i )

inline

set the current boundary ID

Definition at line 434 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 3228 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 502 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 424 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 1932 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

Definition at line 676 of file Assembly.C.

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

Referenced by 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 692 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 737 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 711 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 3533 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 3289 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 3542 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.

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

Definition at line 657 of file Assembly.C.

{
  _current_qrule = qrule;
 
  if (qrule) // Don't set a NULL qrule
  {
    for (auto & it : _fe[dim])
      it.second->attach_quadrature_rule(qrule);
    for (auto & it : _vector_fe[dim])
      it.second->attach_quadrature_rule(qrule);
    if (!_unique_fe_helper.empty())
    {
      mooseAssert(dim < _unique_fe_helper.size(), "We should not be indexing out of bounds");
      _unique_fe_helper[dim]->attach_quadrature_rule(qrule);
    }
  }
}

Referenced by reinit(), and reinit().

setXFEM()

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

inline

Set the pointer to the XFEM controller object.

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

{ return _current_side; }

Referenced by computeADFace(), computeFaceMap(), modifyFaceWeightsDueToXFEM(), qruleArbitraryFace(), qruleFace(), qruleFaceHelper(), 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 458 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 464 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 368 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 241 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 248 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 328 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 335 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 527 of file Assembly.h.

{ return _current_qrule_neighbor; }

zeroCachedJacobian()

void Assembly::zeroCachedJacobian

(

GlobalDataKey

)

Zero out previously-cached Jacobian rows.

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

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

_ad_curvatures

MooseArray<ADReal> Assembly::_ad_curvatures

protected

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

Referenced by computeFaceMap().

_ad_d2xyzdxi2_map

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

protected

Definition at line 2831 of file Assembly.h.

Referenced by computeFaceMap().

_ad_d2xyzdxideta_map

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

protected

Definition at line 2832 of file Assembly.h.

Referenced by computeFaceMap().

_ad_detadx_map

std::vector<ADReal> Assembly::_ad_detadx_map

protected

Definition at line 2840 of file Assembly.h.

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

_ad_detady_map

std::vector<ADReal> Assembly::_ad_detady_map

protected

Definition at line 2841 of file Assembly.h.

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

_ad_detadz_map

std::vector<ADReal> Assembly::_ad_detadz_map

protected

Definition at line 2842 of file Assembly.h.

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

_ad_dxidx_map

std::vector<ADReal> Assembly::_ad_dxidx_map

protected

Definition at line 2837 of file Assembly.h.

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

_ad_dxidy_map

std::vector<ADReal> Assembly::_ad_dxidy_map

protected

Definition at line 2838 of file Assembly.h.

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

_ad_dxidz_map

std::vector<ADReal> Assembly::_ad_dxidz_map

protected

Definition at line 2839 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 2829 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 2828 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 2830 of file Assembly.h.

Referenced by computeSinglePointMapAD(), and resizeADMappingObjects().

_ad_dzetadx_map

std::vector<ADReal> Assembly::_ad_dzetadx_map

protected

Definition at line 2843 of file Assembly.h.

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

_ad_dzetady_map

std::vector<ADReal> Assembly::_ad_dzetady_map

protected

Definition at line 2844 of file Assembly.h.

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

_ad_dzetadz_map

std::vector<ADReal> Assembly::_ad_dzetadz_map

protected

Definition at line 2845 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 2781 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 2783 of file Assembly.h.

Referenced by computeADFace(), feADGradPhiFace(), and ~Assembly().

_ad_jac

std::vector<ADReal> Assembly::_ad_jac

protected

Definition at line 2834 of file Assembly.h.

Referenced by computeSinglePointMapAD(), and resizeADMappingObjects().

_ad_JxW

MooseArray<ADReal> Assembly::_ad_JxW

protected

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

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

_ad_normals

MooseArray<VectorValue<ADReal> > Assembly::_ad_normals

protected

Definition at line 2848 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 2836 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 2849 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 2782 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 2785 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 2816 of file Assembly.h.

Referenced by init(), 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 2377 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 2811 of file Assembly.h.

Referenced by addCachedJacobian(), cacheJacobian(), cacheJacobianBlock(), cacheJacobianBlockNonzero(), clearCachedJacobian(), init(), 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 2809 of file Assembly.h.

Referenced by addCachedJacobian(), cacheJacobian(), cacheJacobianBlock(), cacheJacobianBlockNonzero(), clearCachedJacobian(), init(), setCachedJacobian(), and zeroCachedJacobian().

_cached_jacobian_values

std::vector<std::vector<Real> > Assembly::_cached_jacobian_values

protected

Values cached by calling cacheJacobian()

Definition at line 2807 of file Assembly.h.

Referenced by addCachedJacobian(), cacheJacobian(), cacheJacobianBlock(), cacheJacobianBlockNonzero(), clearCachedJacobian(), init(), 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 2802 of file Assembly.h.

Referenced by addCachedResidualDirectly(), addCachedResiduals(), cacheResidual(), cacheResidual(), cacheResidualLower(), cacheResidualNeighbor(), cacheResidualNodes(), clearCachedResiduals(), and init().

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

Referenced by addCachedResidualDirectly(), addCachedResiduals(), cacheResidual(), cacheResidual(), cacheResidualLower(), cacheResidualNeighbor(), cacheResidualNodes(), clearCachedResiduals(), and init().

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

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

_calculate_curvatures

bool Assembly::_calculate_curvatures

mutableprotected

Definition at line 2860 of file Assembly.h.

Referenced by adCurvatures(), computeADFace(), computeFaceMap(), reinitElemFaceRef(), and reinitFEFace().

_calculate_face_xyz

bool Assembly::_calculate_face_xyz

mutableprotected

Definition at line 2859 of file Assembly.h.

Referenced by adCoordTransformation(), adQPointsFace(), computeADFace(), and computeFaceMap().

_calculate_xyz

bool Assembly::_calculate_xyz

mutableprotected

Definition at line 2858 of file Assembly.h.

Referenced by adCoordTransformation(), adQPoints(), computeSinglePointMapAD(), reinitFE(), and resizeADMappingObjects().

_cm

const libMesh::CouplingMatrix* Assembly::_cm

private

Coupling matrices.

Definition at line 2319 of file Assembly.h.

Referenced by addJacobianBlockNonlocal(), cacheJacobianBlock(), cacheJacobianBlockNonzero(), and init().

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

Referenced by addJacobian(), addJacobianLowerD(), addJacobianNeighbor(), addJacobianNeighborLowerD(), cacheJacobian(), cacheJacobianMortar(), cacheJacobianNeighbor(), couplingEntries(), couplingEntries(), init(), 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 2334 of file Assembly.h.

Referenced by addJacobian(), cacheJacobian(), fieldScalarCouplingEntries(), and init().

_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 2340 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 2336 of file Assembly.h.

Referenced by addJacobian(), cacheJacobian(), init(), 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 2338 of file Assembly.h.

Referenced by addJacobianScalar(), and init().

_column_indices

std::vector<dof_id_type> Assembly::_column_indices

protected

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

Referenced by addJacobianBlockNonlocal(), cacheJacobianBlock(), cacheJacobianBlockNonzero(), init(), 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 2882 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 2326 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 2323 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 2329 of file Assembly.h.

Referenced by computingResidualAndJacobian().

_coord

MooseArray<Real> Assembly::_coord

private

The current coordinate transformation coefficients.

Definition at line 2425 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 2575 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 2572 of file Assembly.h.

Referenced by reinitNeighbor(), and ~Assembly().

_coord_type

Moose::CoordinateSystemType Assembly::_coord_type

private

The coordinate system.

Definition at line 2423 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 2601 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 2597 of file Assembly.h.

Referenced by computeCurrentElemVolume(), computeCurrentFaceVolume(), elem(), 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 2603 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 2627 of file Assembly.h.

Referenced by computeCurrentElemVolume(), 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 2383 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 2385 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 2521 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 2389 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 2409 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 2387 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 2421 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 2529 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 2570 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 2632 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 2638 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 2611 of file Assembly.h.

Referenced by neighbor(), 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 2634 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 2642 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 2625 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 2905 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 2615 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 2617 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 2880 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 2613 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 2621 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 2623 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 2531 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 2647 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 2419 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 2527 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 2566 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 2525 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 2411 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 2415 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 2417 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 2523 of file Assembly.h.

Referenced by clearCachedQRules(), computeADFace(), computeCurrentFaceVolume(), modifyFaceWeightsDueToXFEM(), qRuleFace(), reinit(), reinitElemFaceRef(), reinitFVFace(), setFaceQRule(), 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 2593 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 2564 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 2413 of file Assembly.h.

_current_side

unsigned int Assembly::_current_side

protected

The current side of the selected element (valid only when working with sides)

Definition at line 2605 of file Assembly.h.

Referenced by reinit(), 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 2607 of file Assembly.h.

Referenced by reinit(), 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 2878 of file Assembly.h.

Referenced by reinit(), and reinitFVFace().

_current_side_volume

Real Assembly::_current_side_volume

protected

Volume of the current side element.

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

Referenced by computeCurrentFaceVolume(), reinit(), and reinitFVFace().

_current_subdomain_id

SubdomainID Assembly::_current_subdomain_id

protected

The current subdomain ID.

Definition at line 2599 of file Assembly.h.

Referenced by currentSubdomainID(), qrules(), 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 2535 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 2392 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 2394 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 2398 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 2396 of file Assembly.h.

Referenced by reinitFENeighbor().

_curvatures

MooseArray<Real> Assembly::_curvatures

protected

Definition at line 2850 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 2589 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 2856 of file Assembly.h.

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

_displaced

const bool Assembly::_displaced

private

Definition at line 2316 of file Assembly.h.

Referenced by computeADFace(), and reinitFE().

_dof_map

const libMesh::DofMap& Assembly::_dof_map

private

DOF map.

Definition at line 2349 of file Assembly.h.

Referenced by 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 2894 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 2889 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 2538 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 2403 of file Assembly.h.

Referenced by Assembly(), buildFE(), getFE(), havePRefinement(), reinitFE(), setVolumeQRule(), and ~Assembly().

_fe_face

std::map<unsigned int, std::map<FEType, FEBase *> > Assembly::_fe_face

mutableprivate

types of finite elements

Definition at line 2515 of file Assembly.h.

Referenced by Assembly(), buildFaceFE(), computeADFace(), getFEFace(), havePRefinement(), reinitElemFaceRef(), reinitFEFace(), setFaceQRule(), and ~Assembly().

_fe_face_neighbor

std::map<unsigned int, std::map<FEType, FEBase *> > Assembly::_fe_face_neighbor

mutableprivate

Definition at line 2548 of file Assembly.h.

Referenced by Assembly(), buildFaceNeighborFE(), getFEFaceNeighbor(), havePRefinement(), 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 2557 of file Assembly.h.

Referenced by Assembly(), buildLowerDDualFE(), buildLowerDFE(), havePRefinement(), 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 2582 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 2547 of file Assembly.h.

Referenced by Assembly(), buildNeighborFE(), getFENeighbor(), havePRefinement(), 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 2766 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 2771 of file Assembly.h.

Referenced by buildLowerDDualFE(), feDualPhiLower(), feGradDualPhiLower(), and reinitLowerDElem().

_fe_shape_data_face

std::map<FEType, std::unique_ptr<FEShapeData> > Assembly::_fe_shape_data_face

mutableprotected

Definition at line 2767 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 2769 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 2770 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 2768 of file Assembly.h.

Referenced by buildNeighborFE(), feCurlPhiNeighbor(), feDivPhiNeighbor(), feGradPhiNeighbor(), fePhiNeighbor(), feSecondPhiNeighbor(), and reinitFENeighbor().

_grad_phi

VariablePhiGradient Assembly::_grad_phi

protected

Definition at line 2705 of file Assembly.h.

Referenced by gradPhi(), gradPhi(), gradPhi(), and gradPhi().

_grad_phi_face

VariablePhiGradient Assembly::_grad_phi_face

protected

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

Referenced by gradPhiFaceNeighbor(), gradPhiFaceNeighbor(), and gradPhiFaceNeighbor().

_grad_phi_neighbor

VariablePhiGradient Assembly::_grad_phi_neighbor

protected

Definition at line 2713 of file Assembly.h.

Referenced by gradPhiNeighbor(), gradPhiNeighbor(), and gradPhiNeighbor().

_have_p_refinement

bool Assembly::_have_p_refinement

protected

Whether we have ever conducted p-refinement.

Definition at line 2902 of file Assembly.h.

Referenced by havePRefinement().

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

Referenced by buildFaceFE(), buildFaceNeighborFE(), buildFE(), buildLowerDFE(), and buildNeighborFE().

_holder_fe_face_helper

std::map<unsigned int, FEBase *> Assembly::_holder_fe_face_helper

private

Each dimension's helper objects.

Definition at line 2519 of file Assembly.h.

Referenced by Assembly(), computeADFace(), computeFaceMap(), havePRefinement(), helpersRequestData(), reinitElemFaceRef(), and reinitFEFace().

_holder_fe_face_neighbor_helper

std::map<unsigned int, FEBase *> Assembly::_holder_fe_face_neighbor_helper

private

Definition at line 2554 of file Assembly.h.

Referenced by Assembly(), havePRefinement(), helpersRequestData(), reinitFEFaceNeighbor(), and reinitNeighborFaceRef().

_holder_fe_helper

std::map<unsigned int, FEBase *> Assembly::_holder_fe_helper

private

Each dimension's helper objects.

Definition at line 2407 of file Assembly.h.

Referenced by Assembly(), havePRefinement(), helpersRequestData(), 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 2561 of file Assembly.h.

Referenced by Assembly(), havePRefinement(), helpersRequestData(), 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 2553 of file Assembly.h.

Referenced by Assembly(), havePRefinement(), helpersRequestData(), 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 2542 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 2347 of file Assembly.h.

Referenced by addJacobianLowerD(), addJacobianNeighborLowerD(), cacheJacobianMortar(), init(), 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 2345 of file Assembly.h.

Referenced by addJacobianNeighbor(), addJacobianNeighborLowerD(), cacheJacobianNeighbor(), init(), 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 2343 of file Assembly.h.

Referenced by addJacobianNonlocal(), cacheJacobianNonlocal(), init(), 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 2342 of file Assembly.h.

Referenced by addJacobianCoupledVarPair(), cacheJacobianCoupledVarPair(), init(), 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 2580 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 2533 of file Assembly.h.

Referenced by mappedNormals(), and reinitFEFace().

_max_cached_jacobians

unsigned int Assembly::_max_cached_jacobians

protected

Definition at line 2813 of file Assembly.h.

Referenced by addCachedJacobian().

_max_cached_residuals

unsigned int Assembly::_max_cached_residuals

protected

Definition at line 2804 of file Assembly.h.

Referenced by clearCachedResiduals().

_mesh

MooseMesh& Assembly::_mesh

private

Definition at line 2353 of file Assembly.h.

Referenced by adCurvatures(), Assembly(), and havePRefinement().

_mesh_dimension

unsigned int Assembly::_mesh_dimension

private

Definition at line 2355 of file Assembly.h.

Referenced by Assembly(), buildFaceFE(), buildFaceNeighborFE(), buildFE(), buildLowerDDualFE(), buildLowerDFE(), buildNeighborFE(), buildVectorDualLowerDFE(), buildVectorFaceFE(), buildVectorFaceNeighborFE(), buildVectorFE(), buildVectorLowerDFE(), buildVectorNeighborFE(), bumpAllQRuleOrder(), bumpVolumeQRuleOrder(), createQRules(), havePRefinement(), helpersRequestData(), reinitDual(), reinitLowerDElem(), reinitMortarElem(), reinitNeighborLowerDElem(), and ~Assembly().

_msm_elem

const Elem* Assembly::_msm_elem = nullptr

protected

Definition at line 2884 of file Assembly.h.

Referenced by msmElem(), and reinitMortarElem().

_need_curl

std::set<FEType> Assembly::_need_curl

mutableprotected

Definition at line 2868 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 2869 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 2644 of file Assembly.h.

Referenced by activateDual(), and needDual().

_need_face_div

std::set<FEType> Assembly::_need_face_div

mutableprotected

Definition at line 2870 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 2872 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 2568 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 2636 of file Assembly.h.

Referenced by lowerDElemVolume(), and reinitLowerDElem().

_need_neighbor_div

std::set<FEType> Assembly::_need_neighbor_div

mutableprotected

Definition at line 2871 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 2619 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 2640 of file Assembly.h.

Referenced by neighborLowerDElemVolume(), and reinitNeighborLowerDElem().

_need_second_derivative

std::set<FEType> Assembly::_need_second_derivative

mutableprotected

Definition at line 2866 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 2867 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 2540 of file Assembly.h.

Referenced by Assembly(), extraElemIDNeighbor(), and reinitNeighbor().

_nonlocal_cm

const libMesh::CouplingMatrix& Assembly::_nonlocal_cm

private

Definition at line 2320 of file Assembly.h.

Referenced by initNonlocalCoupling().

_phi

VariablePhiValue Assembly::_phi

protected

Definition at line 2704 of file Assembly.h.

Referenced by phi(), phi(), phi(), and phi().

_phi_face

VariablePhiValue Assembly::_phi_face

protected

Definition at line 2708 of file Assembly.h.

Referenced by phiFace(), phiFace(), phiFace(), and phiFace().

_phi_face_neighbor

VariablePhiValue Assembly::_phi_face_neighbor

protected

Definition at line 2716 of file Assembly.h.

Referenced by phiFaceNeighbor(), phiFaceNeighbor(), and phiFaceNeighbor().

_phi_neighbor

VariablePhiValue Assembly::_phi_neighbor

protected

Definition at line 2712 of file Assembly.h.

Referenced by phiNeighbor(), phiNeighbor(), and phiNeighbor().

_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 2587 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 2460 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 2796 of file Assembly.h.

Referenced by clearCachedResiduals(), and init().

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

Referenced by cacheJacobian(), cacheJacobianBlock(), and cacheResiduals().

_scaling_vector

const NumericVector<Real>* Assembly::_scaling_vector = nullptr

protected

The map from global index to variable scaling factor.

Definition at line 2875 of file Assembly.h.

Referenced by hasScalingVector().

_second_phi

VariablePhiSecond Assembly::_second_phi

protected

Definition at line 2706 of file Assembly.h.

Referenced by secondPhi(), secondPhi(), secondPhi(), and secondPhi().

_second_phi_face

VariablePhiSecond Assembly::_second_phi_face

protected

Definition at line 2710 of file Assembly.h.

Referenced by secondPhiFace(), secondPhiFace(), and secondPhiFace().

_second_phi_face_neighbor

VariablePhiSecond Assembly::_second_phi_face_neighbor

protected

Definition at line 2718 of file Assembly.h.

Referenced by secondPhiFaceNeighbor(), secondPhiFaceNeighbor(), and secondPhiFaceNeighbor().

_second_phi_neighbor

VariablePhiSecond Assembly::_second_phi_neighbor

protected

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

Referenced by init(), jacobianBlock(), jacobianBlockMortar(), and jacobianBlockNeighbor().

_sub_Keg

std::vector<std::vector<std::vector<DenseMatrix<Number> > > > Assembly::_sub_Keg

protected

Definition at line 2681 of file Assembly.h.

Referenced by init(), and jacobianBlockNonlocal().

_sub_Kel

std::vector<std::vector<std::vector<DenseMatrix<Number> > > > Assembly::_sub_Kel

protected

dsecondary/dlower (or delement/dlower)

Definition at line 2696 of file Assembly.h.

Referenced by init(), and 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 2684 of file Assembly.h.

Referenced by init(), 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 2692 of file Assembly.h.

Referenced by init(), and jacobianBlockMortar().

_sub_Kll

std::vector<std::vector<std::vector<DenseMatrix<Number> > > > Assembly::_sub_Kll

protected

dlower/dlower

Definition at line 2690 of file Assembly.h.

Referenced by init(), and jacobianBlockMortar().

_sub_Kln

std::vector<std::vector<std::vector<DenseMatrix<Number> > > > Assembly::_sub_Kln

protected

dlower/dprimary (or dlower/dneighbor)

Definition at line 2694 of file Assembly.h.

Referenced by init(), and 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 2686 of file Assembly.h.

Referenced by init(), 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 2698 of file Assembly.h.

Referenced by init(), and 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 2688 of file Assembly.h.

Referenced by init(), jacobianBlockMortar(), and jacobianBlockNeighbor().

_sub_Re

std::vector<std::vector<DenseVector<Number> > > Assembly::_sub_Re

protected

Definition at line 2661 of file Assembly.h.

Referenced by addResidual(), addResidualScalar(), cacheResidual(), init(), 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 2664 of file Assembly.h.

Referenced by addResidualLower(), cacheResidualLower(), init(), prepareLowerD(), and residualBlockLower().

_sub_Rn

std::vector<std::vector<DenseVector<Number> > > Assembly::_sub_Rn

protected

Definition at line 2662 of file Assembly.h.

Referenced by addResidualNeighbor(), cacheResidualNeighbor(), init(), prepareNeighbor(), residualBlockNeighbor(), and setResidualNeighbor().

_subproblem

SubProblem& Assembly::_subproblem

private

Definition at line 2314 of file Assembly.h.

Referenced by addCachedJacobian(), cacheResidual(), cacheResidualNodes(), computeADFace(), computeFaceMap(), computeSinglePointMapAD(), elementVolume(), init(), reinitFE(), reinitLowerDElem(), reinitNeighborLowerDElem(), and setCoordinateTransformation().

_sys

SystemBase& Assembly::_sys

private

Definition at line 2313 of file Assembly.h.

Referenced by addCachedJacobian(), addCachedResiduals(), addJacobianBlockNonlocal(), addJacobianCoupledVarPair(), addJacobianLowerD(), addJacobianNeighbor(), addJacobianNeighborLowerD(), addJacobianNonlocal(), addJacobianOffDiagScalar(), addResidual(), addResidual(), addResidualLower(), addResidualLower(), addResidualNeighbor(), addResidualNeighbor(), addResidualScalar(), addResidualScalar(), cacheJacobian(), cacheJacobianBlock(), cacheJacobianBlock(), cacheJacobianBlockNonzero(), cacheJacobianCoupledVarPair(), cacheJacobianMortar(), cacheJacobianNeighbor(), cacheJacobianNonlocal(), cacheResidual(), cacheResidualLower(), cacheResidualNeighbor(), computeFaceMap(), computeSinglePointMapAD(), copyFaceShapes(), copyNeighborShapes(), copyShapes(), hasScalingVector(), init(), 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 2822 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 2825 of file Assembly.h.

Referenced by reinitAtPhysical().

_tid

THREAD_ID Assembly::_tid

private

Thread number (id)

Definition at line 2351 of file Assembly.h.

Referenced by addJacobianBlockNonlocal(), addJacobianOffDiagScalar(), addResidual(), addResidualLower(), addResidualNeighbor(), addResidualScalar(), cacheResidual(), cacheResidualLower(), cacheResidualNeighbor(), copyFaceShapes(), copyNeighborShapes(), copyShapes(), init(), 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 2701 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 2667 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 2371 of file Assembly.h.

Referenced by havePRefinement(), reinitElemFaceRef(), reinitFEFace(), and setFaceQRule().

_unique_fe_face_neighbor_helper

std::vector<std::unique_ptr<FEBase> > Assembly::_unique_fe_face_neighbor_helper

private

Definition at line 2372 of file Assembly.h.

Referenced by havePRefinement(), 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 2370 of file Assembly.h.

Referenced by havePRefinement(), reinitFE(), and setVolumeQRule().

_unique_fe_lower_helper

std::vector<std::unique_ptr<FEBase> > Assembly::_unique_fe_lower_helper

private

Definition at line 2374 of file Assembly.h.

Referenced by havePRefinement(), reinitLowerDElem(), and setLowerQRule().

_unique_fe_neighbor_helper

std::vector<std::unique_ptr<FEBase> > Assembly::_unique_fe_neighbor_helper

private

Definition at line 2373 of file Assembly.h.

Referenced by havePRefinement(), and reinitFENeighbor().

_user_added_fe_face_neighbor_of_helper_type

bool Assembly::_user_added_fe_face_neighbor_of_helper_type

mutableprivate

Definition at line 2364 of file Assembly.h.

Referenced by buildFaceNeighborFE(), and havePRefinement().

_user_added_fe_face_of_helper_type

bool Assembly::_user_added_fe_face_of_helper_type

mutableprivate

Definition at line 2363 of file Assembly.h.

Referenced by buildFaceFE(), and havePRefinement().

_user_added_fe_lower_of_helper_type

bool Assembly::_user_added_fe_lower_of_helper_type

mutableprivate

Definition at line 2366 of file Assembly.h.

Referenced by buildLowerDFE(), and havePRefinement().

_user_added_fe_neighbor_of_helper_type

bool Assembly::_user_added_fe_neighbor_of_helper_type

mutableprivate

Definition at line 2365 of file Assembly.h.

Referenced by buildNeighborFE(), and havePRefinement().

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

Referenced by buildFE(), and havePRefinement().

_vector_curl_phi

VectorVariablePhiCurl Assembly::_vector_curl_phi

protected

Definition at line 2724 of file Assembly.h.

Referenced by curlPhi(), and curlPhi().

_vector_curl_phi_face

VectorVariablePhiCurl Assembly::_vector_curl_phi_face

protected

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

Referenced by curlPhiFaceNeighbor(), and curlPhiFaceNeighbor().

_vector_curl_phi_neighbor

VectorVariablePhiCurl Assembly::_vector_curl_phi_neighbor

protected

Definition at line 2736 of file Assembly.h.

Referenced by curlPhiNeighbor(), and curlPhiNeighbor().

_vector_div_phi

VectorVariablePhiDivergence Assembly::_vector_div_phi

protected

Definition at line 2725 of file Assembly.h.

Referenced by divPhi(), and divPhi().

_vector_div_phi_face

VectorVariablePhiDivergence Assembly::_vector_div_phi_face

protected

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

Referenced by divPhiFaceNeighbor(), and divPhiFaceNeighbor().

_vector_div_phi_neighbor

VectorVariablePhiDivergence Assembly::_vector_div_phi_neighbor

protected

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

Referenced by buildVectorFE(), getVectorFE(), havePRefinement(), reinitFE(), setVolumeQRule(), 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 2517 of file Assembly.h.

Referenced by buildVectorFaceFE(), computeADFace(), getVectorFEFace(), havePRefinement(), reinitElemFaceRef(), reinitFEFace(), setFaceQRule(), and ~Assembly().

_vector_fe_face_neighbor

std::map<unsigned int, std::map<FEType, FEVectorBase *> > Assembly::_vector_fe_face_neighbor

mutableprivate

Definition at line 2550 of file Assembly.h.

Referenced by buildVectorFaceNeighborFE(), getVectorFEFaceNeighbor(), havePRefinement(), 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 2559 of file Assembly.h.

Referenced by buildVectorDualLowerDFE(), buildVectorLowerDFE(), havePRefinement(), setLowerQRule(), and ~Assembly().

_vector_fe_neighbor

std::map<unsigned int, std::map<FEType, FEVectorBase *> > Assembly::_vector_fe_neighbor

mutableprivate

Definition at line 2549 of file Assembly.h.

Referenced by buildVectorNeighborFE(), getVectorFENeighbor(), havePRefinement(), 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 2774 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 2779 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 2775 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 2777 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 2778 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 2776 of file Assembly.h.

Referenced by buildVectorNeighborFE(), and reinitFENeighbor().

_vector_grad_phi

VectorVariablePhiGradient Assembly::_vector_grad_phi

protected

Definition at line 2722 of file Assembly.h.

Referenced by gradPhi(), and gradPhi().

_vector_grad_phi_face

VectorVariablePhiGradient Assembly::_vector_grad_phi_face

protected

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

Referenced by gradPhiFaceNeighbor(), and gradPhiFaceNeighbor().

_vector_grad_phi_neighbor

VectorVariablePhiGradient Assembly::_vector_grad_phi_neighbor

protected

Definition at line 2734 of file Assembly.h.

Referenced by gradPhiNeighbor(), and gradPhiNeighbor().

_vector_phi

VectorVariablePhiValue Assembly::_vector_phi

protected

Definition at line 2721 of file Assembly.h.

Referenced by phi(), and phi().

_vector_phi_face

VectorVariablePhiValue Assembly::_vector_phi_face

protected

Definition at line 2727 of file Assembly.h.

Referenced by phiFace(), and phiFace().

_vector_phi_face_neighbor

VectorVariablePhiValue Assembly::_vector_phi_face_neighbor

protected

Definition at line 2739 of file Assembly.h.

Referenced by phiFaceNeighbor(), and phiFaceNeighbor().

_vector_phi_neighbor

VectorVariablePhiValue Assembly::_vector_phi_neighbor

protected

Definition at line 2733 of file Assembly.h.

Referenced by phiNeighbor(), and phiNeighbor().

_vector_second_phi

VectorVariablePhiSecond Assembly::_vector_second_phi

protected

Definition at line 2723 of file Assembly.h.

Referenced by secondPhi(), and secondPhi().

_vector_second_phi_face

VectorVariablePhiSecond Assembly::_vector_second_phi_face

protected

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

Referenced by secondPhiFaceNeighbor(), and secondPhiFaceNeighbor().

_vector_second_phi_neighbor

VectorVariablePhiSecond Assembly::_vector_second_phi_neighbor

protected

Definition at line 2735 of file Assembly.h.

Referenced by secondPhiNeighbor(), and secondPhiNeighbor().

_xfem

std::shared_ptr<XFEMInterface> Assembly::_xfem

private

The XFEM controller.

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