https://mooseframework.inl.gov
Loading...
Searching...
No Matches
Classes | Public Types | Public Member Functions | Static Public Member Functions | Protected Attributes | Private Member Functions | Private Attributes | List of all members
Assembly Class Reference

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

#include <Assembly.h>

Classes

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

Public Types

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

Public Member Functions

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

Static Public Member Functions

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

Protected Attributes

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

Private Member Functions

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

Private Attributes

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

Detailed Description

Keeps track of stuff related to assembling.

Definition at line 101 of file Assembly.h.

Member Typedef Documentation

◆ InternalDataKey

Key structure for APIs manipulating internal shape and quadrature data.

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

Definition at line 220 of file Assembly.h.

Constructor & Destructor Documentation

◆ Assembly()

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

Definition at line 79 of file Assembly.C.

80 : _sys(sys),
82 _displaced(dynamic_cast<DisplacedSystem *>(&sys) ? true : false),
83 _nonlocal_cm(_subproblem.nonlocalCouplingMatrix(_sys.number())),
84 _computing_residual(_subproblem.currentlyComputingResidual()),
85 _computing_jacobian(_subproblem.currentlyComputingJacobian()),
86 _computing_residual_and_jacobian(_subproblem.currentlyComputingResidualAndJacobian()),
87 _dof_map(_sys.dofMap()),
88 _tid(tid),
89 _mesh(sys.mesh()),
90 _mesh_dimension(_mesh.dimension()),
92 FEType(_mesh.hasSecondOrderElements() ? SECOND : FIRST, LAGRANGE).set_p_refinement(false)),
98 _building_helpers(false),
99 _current_qrule(nullptr),
100 _current_qrule_volume(nullptr),
103 _current_qrule_face(nullptr),
106 _need_JxW_neighbor(false),
107 _qrule_msm(nullptr),
109 _current_qrule_lower(nullptr),
110
111 _current_elem(nullptr),
113 _current_side(0),
114 _current_side_elem(nullptr),
116 _current_neighbor_elem(nullptr),
121 _current_node(nullptr),
122 _current_neighbor_node(nullptr),
125
126 _current_lower_d_elem(nullptr),
130 _need_dual(false),
131
133 _cached_residual_values(2), // The 2 is for TIME and NONTIME
134 _cached_residual_rows(2), // The 2 is for TIME and NONTIME
137
139 _calculate_xyz(false),
140 _calculate_face_xyz(false),
142 _calculate_ad_coord(false),
144{
145 const Order helper_order = _mesh.hasSecondOrderElements() ? SECOND : FIRST;
146 _building_helpers = true;
147 // Build fe's for the helpers
153 _building_helpers = false;
154
155 // Build an FE helper object for this type for each dimension up to the dimension of the current
156 // mesh
157 for (unsigned int dim = 0; dim <= _mesh_dimension; dim++)
158 {
163 }
164
165 for (unsigned int dim = 0; dim < _mesh_dimension; dim++)
167
168 // request phi, dphi, xyz, JxW, etc. data
170
171 // For 3D mortar, mortar segments are always TRI3 elements so we want FIRST LAGRANGE regardless
172 // of discretization
173 const auto mortar_helper_type =
174 FEType(_mesh_dimension == 2 ? helper_order : FIRST, LAGRANGE).set_p_refinement(false);
175 _fe_msm = FEGenericBase<Real>::build(_mesh_dimension - 1, mortar_helper_type);
176 // This FE object should not take part in p-refinement
177 _fe_msm->add_p_level_in_reinit(false);
178 _JxW_msm = &_fe_msm->get_JxW();
179 // Prerequest xyz so that it is computed for _fe_msm so that it can be used for calculating
180 // _coord_msm
181 _fe_msm->get_xyz();
182
183 _extra_elem_ids.resize(_mesh.getMesh().n_elem_integers() + 1);
184 _neighbor_extra_elem_ids.resize(_mesh.getMesh().n_elem_integers() + 1);
185}
unsigned int dim
SystemBase & _sys
Definition Assembly.h:2311
std::map< unsigned int, FEBase * > _holder_fe_lower_helper
helper object for transforming coordinates for lower dimensional element quadrature points
Definition Assembly.h:2559
const bool & _computing_jacobian
Whether we are currently computing the Jacobian.
Definition Assembly.h:2324
const std::vector< Real > * _JxW_msm
A JxW for working on mortar segement elements.
Definition Assembly.h:2578
const bool _displaced
Definition Assembly.h:2314
libMesh::QBase * _current_qrule_face
quadrature rule used on faces
Definition Assembly.h:2521
bool _block_diagonal_matrix
Will be true if our preconditioning matrix is a block-diagonal matrix. Which means that we can take s...
Definition Assembly.h:2828
bool _current_side_volume_computed
Boolean to indicate whether current element side volumes has been computed.
Definition Assembly.h:2627
const FEType _helper_type
The finite element type of the FE helper classes.
Definition Assembly.h:2357
Real _current_elem_volume
Volume of the current element.
Definition Assembly.h:2601
bool _building_helpers
Whether we are currently building the FE classes for the helpers.
Definition Assembly.h:2375
libMesh::QBase * _current_qrule
The current current quadrature rule being used (could be either volumetric or arbitrary - for dirac k...
Definition Assembly.h:2409
const bool & _computing_residual
Whether we are currently computing the residual.
Definition Assembly.h:2321
bool _need_JxW_neighbor
Flag to indicate that JxW_neighbor is needed.
Definition Assembly.h:2566
bool _user_added_fe_of_helper_type
Whether user code requested a FEType the same as our _helper_type.
Definition Assembly.h:2360
bool _calculate_xyz
Definition Assembly.h:2870
void buildFaceNeighborFE(FEType type) const
Build FEs for a neighbor face with a type.
Definition Assembly.C:346
const libMesh::CouplingMatrix & _nonlocal_cm
Definition Assembly.h:2318
Real _current_neighbor_volume
Volume of the current neighbor.
Definition Assembly.h:2619
bool _need_neighbor_lower_d_elem_volume
Whether we need to compute the neighboring lower dimensional element volume.
Definition Assembly.h:2638
Moose::CoordinateSystemType _coord_type
The coordinate system.
Definition Assembly.h:2421
std::map< unsigned int, std::map< FEType, FEBase * > > _fe_lower
FE objects for lower dimensional elements.
Definition Assembly.h:2555
const libMesh::DofMap & _dof_map
DOF map.
Definition Assembly.h:2347
std::map< unsigned int, std::map< FEType, FEBase * > > _fe_face_neighbor
Definition Assembly.h:2546
bool _prepared_for_p_refinement
Whether helper FEs have been prepared for p-refinement.
Definition Assembly.h:2911
const Elem * _current_lower_d_elem
The current lower dimensional element.
Definition Assembly.h:2630
unsigned int _current_side
The current side of the selected element (valid only when working with sides)
Definition Assembly.h:2603
const bool & _computing_residual_and_jacobian
Whether we are currently computing the residual and Jacobian.
Definition Assembly.h:2327
void buildNeighborFE(FEType type) const
Build FEs for a neighbor with a type.
Definition Assembly.C:321
std::unique_ptr< FEBase > _fe_msm
A FE object for working on mortar segement elements.
Definition Assembly.h:2580
const Node * _current_neighbor_node
The current neighboring node we are working with.
Definition Assembly.h:2623
void buildFE(FEType type) const
Build FEs with a type.
Definition Assembly.C:267
const Elem * _current_neighbor_side_elem
The current side element of the ncurrent neighbor element.
Definition Assembly.h:2615
bool _calculate_ad_coord
Whether to calculate coord with AD.
Definition Assembly.h:2876
void helpersRequestData()
request phi, dphi, xyz, JxW, etc.
Definition Assembly.C:4869
libMesh::QBase * _current_qrule_neighbor
quadrature rule used on neighbors
Definition Assembly.h:2562
void buildLowerDFE(FEType type) const
Build FEs for a lower dimensional element with a type.
Definition Assembly.C:371
std::map< unsigned int, std::map< FEType, FEBase * > > _fe_neighbor
types of finite elements
Definition Assembly.h:2545
std::map< unsigned int, std::map< FEType, FEBase * > > _fe
Each dimension's actual fe objects indexed on type.
Definition Assembly.h:2401
bool _current_elem_volume_computed
Boolean to indicate whether current element volumes has been computed.
Definition Assembly.h:2625
std::map< unsigned int, std::map< FEType, FEBase * > > _fe_face
types of finite elements
Definition Assembly.h:2513
const std::vector< VectorTag > & _residual_vector_tags
The residual vector tags that Assembly could possibly contribute to.
Definition Assembly.h:2808
const Elem * _current_neighbor_elem
The current neighbor "element".
Definition Assembly.h:2609
bool _user_added_fe_face_neighbor_of_helper_type
Definition Assembly.h:2362
MooseMesh & _mesh
Definition Assembly.h:2351
ArbitraryQuadrature * _current_qface_arbitrary
The current arbitrary quadrature rule used on element faces.
Definition Assembly.h:2523
const Node * _current_node
The current node we are working with.
Definition Assembly.h:2621
THREAD_ID _tid
Thread number (id)
Definition Assembly.h:2349
bool _calculate_face_xyz
Definition Assembly.h:2871
bool _calculate_curvatures
Definition Assembly.h:2872
std::vector< std::vector< Real > > _cached_residual_values
Values cached by calling cacheResidual() (the first vector is for TIME vs NONTIME)
Definition Assembly.h:2811
ArbitraryQuadrature * _current_qrule_arbitrary
The current arbitrary quadrature rule used within the element interior.
Definition Assembly.h:2413
std::vector< dof_id_type > _neighbor_extra_elem_ids
Extra element IDs of neighbor.
Definition Assembly.h:2538
unsigned int _max_cached_residuals
Definition Assembly.h:2816
void buildFaceFE(FEType type) const
Build FEs for a face with a type.
Definition Assembly.C:296
std::map< unsigned int, FEBase * > _holder_fe_face_neighbor_helper
Definition Assembly.h:2552
bool _custom_mortar_qrule
Flag specifying whether a custom quadrature rule has been specified for mortar segment mesh.
Definition Assembly.h:2587
bool _need_lower_d_elem_volume
Whether we need to compute the lower dimensional element volume.
Definition Assembly.h:2634
bool _need_neighbor_elem_volume
true is apps need to compute neighbor element volume
Definition Assembly.h:2617
SubProblem & _subproblem
Definition Assembly.h:2312
Real _current_side_volume
Volume of the current side element.
Definition Assembly.h:2607
bool _user_added_fe_neighbor_of_helper_type
Definition Assembly.h:2363
std::map< unsigned int, FEBase * > _holder_fe_neighbor_helper
Each dimension's helper objects.
Definition Assembly.h:2551
libMesh::QBase * _qrule_msm
A qrule object for working on mortar segement elements.
Definition Assembly.h:2585
unsigned int _max_cached_jacobians
Definition Assembly.h:2825
const Elem * _current_side_elem
The current "element" making up the side we are currently on.
Definition Assembly.h:2605
std::vector< std::vector< dof_id_type > > _cached_residual_rows
Where the cached values should go (the first vector is for TIME vs NONTIME)
Definition Assembly.h:2814
std::map< unsigned int, FEBase * > _holder_fe_helper
Each dimension's helper objects.
Definition Assembly.h:2405
const Elem * _current_neighbor_lower_d_elem
The current neighboring lower dimensional element.
Definition Assembly.h:2632
libMesh::QBase * _current_qrule_lower
quadrature rule used on lower dimensional elements.
Definition Assembly.h:2591
unsigned int _current_neighbor_side
The current side of the selected neighboring element (valid only when working with sides)
Definition Assembly.h:2613
const Elem * _current_elem
The current "element" we are currently on.
Definition Assembly.h:2595
std::map< unsigned int, FEBase * > _holder_fe_face_helper
Each dimension's helper objects.
Definition Assembly.h:2517
libMesh::QBase * _current_qrule_volume
The current volumetric quadrature for the element.
Definition Assembly.h:2411
bool _user_added_fe_face_of_helper_type
Definition Assembly.h:2361
std::vector< dof_id_type > _extra_elem_ids
Extra element IDs.
Definition Assembly.h:2536
bool _user_added_fe_lower_of_helper_type
Definition Assembly.h:2364
unsigned int _mesh_dimension
Definition Assembly.h:2353
bool _need_dual
Whether dual shape functions need to be computed for mortar constraints.
Definition Assembly.h:2642
MeshBase & getMesh()
Accessor for the underlying libMesh Mesh object.
Definition MooseMesh.C:3546
bool hasSecondOrderElements()
check if the mesh has SECOND order elements
Definition MooseMesh.C:3813
SubProblem & subproblem()
Definition SystemBase.h:102
MeshBase & mesh
MOOSE now contains C++17 code, so give a reasonable error message stating what the user can do to add...
@ VECTOR_TAG_RESIDUAL
@ COORD_XYZ
Definition MooseTypes.h:869

◆ ~Assembly()

Assembly::~Assembly ( )
virtual

Definition at line 187 of file Assembly.C.

188{
189 for (unsigned int dim = 0; dim <= _mesh_dimension; dim++)
190 for (auto & it : _fe[dim])
191 delete it.second;
192
193 for (unsigned int dim = 0; dim <= _mesh_dimension; dim++)
194 for (auto & it : _fe_face[dim])
195 delete it.second;
196
197 for (unsigned int dim = 0; dim <= _mesh_dimension; dim++)
198 for (auto & it : _fe_neighbor[dim])
199 delete it.second;
200
201 for (unsigned int dim = 0; dim <= _mesh_dimension; dim++)
202 for (auto & it : _fe_face_neighbor[dim])
203 delete it.second;
204
205 for (unsigned int dim = 0; dim <= _mesh_dimension - 1; dim++)
206 for (auto & it : _fe_lower[dim])
207 delete it.second;
208
209 for (unsigned int dim = 0; dim <= _mesh_dimension; dim++)
210 for (auto & it : _vector_fe[dim])
211 delete it.second;
212
213 for (unsigned int dim = 0; dim <= _mesh_dimension; dim++)
214 for (auto & it : _vector_fe_face[dim])
215 delete it.second;
216
217 for (unsigned int dim = 0; dim <= _mesh_dimension; dim++)
218 for (auto & it : _vector_fe_neighbor[dim])
219 delete it.second;
220
221 for (unsigned int dim = 0; dim <= _mesh_dimension; dim++)
222 for (auto & it : _vector_fe_face_neighbor[dim])
223 delete it.second;
224
225 for (unsigned int dim = 0; dim <= _mesh_dimension - 1; dim++)
226 for (auto & it : _vector_fe_lower[dim])
227 delete it.second;
228
229 for (auto & it : _ad_grad_phi_data)
230 it.second.release();
231
232 for (auto & it : _ad_vector_grad_phi_data)
233 it.second.release();
234
235 for (auto & it : _ad_grad_phi_data_face)
236 it.second.release();
237
238 for (auto & it : _ad_vector_grad_phi_data_face)
239 it.second.release();
240
242
243 _coord.release();
246
255
256 delete _qrule_msm;
257}
MooseArray< Real > _curvatures
Definition Assembly.h:2862
MooseArray< Real > _coord_neighbor
The current coordinate transformation coefficients.
Definition Assembly.h:2570
MooseArray< VectorValue< ADReal > > _ad_q_points
Definition Assembly.h:2848
MooseArray< Point > _current_physical_points
This will be filled up with the physical points passed into reinitAtPhysical() if it is called....
Definition Assembly.h:2645
MooseArray< VectorValue< ADReal > > _ad_normals
Definition Assembly.h:2860
std::map< FEType, ADTemplateVariablePhiGradient< RealVectorValue > > _ad_vector_grad_phi_data
Definition Assembly.h:2780
std::map< unsigned int, std::map< FEType, FEVectorBase * > > _vector_fe
Each dimension's actual vector fe objects indexed on type.
Definition Assembly.h:2403
MooseArray< ADReal > _ad_JxW_face
Definition Assembly.h:2859
std::map< unsigned int, std::map< FEType, FEVectorBase * > > _vector_fe_neighbor
Definition Assembly.h:2547
MooseArray< ADReal > _ad_JxW
Definition Assembly.h:2847
std::map< unsigned int, std::map< FEType, FEVectorBase * > > _vector_fe_face
types of vector finite elements
Definition Assembly.h:2515
std::map< FEType, ADTemplateVariablePhiGradient< RealVectorValue > > _ad_vector_grad_phi_data_face
Definition Assembly.h:2783
std::map< unsigned int, std::map< FEType, FEVectorBase * > > _vector_fe_lower
Vector FE objects for lower dimensional elements.
Definition Assembly.h:2557
std::map< FEType, ADTemplateVariablePhiGradient< Real > > _ad_grad_phi_data_face
Definition Assembly.h:2781
MooseArray< ADReal > _ad_coord
The AD version of the current coordinate transformation coefficients.
Definition Assembly.h:2425
MooseArray< Real > _coord
The current coordinate transformation coefficients.
Definition Assembly.h:2423
MooseArray< ADReal > _ad_curvatures
Definition Assembly.h:2863
std::map< FEType, ADTemplateVariablePhiGradient< Real > > _ad_grad_phi_data
Definition Assembly.h:2779
MooseArray< VectorValue< ADReal > > _ad_q_points_face
Definition Assembly.h:2861
std::map< unsigned int, std::map< FEType, FEVectorBase * > > _vector_fe_face_neighbor
Definition Assembly.h:2548
MooseArray< Real > _coord_msm
The coordinate transformation coefficients evaluated on the quadrature points of the mortar segment m...
Definition Assembly.h:2573
void release()
Manually deallocates the data pointer.
Definition MooseArray.h:66

Member Function Documentation

◆ activateDual()

void Assembly::activateDual ( )
inline

Indicates that dual shape functions are used for mortar constraint.

Definition at line 613 of file Assembly.h.

613{ _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 2918 of file Assembly.h.

2919{
2920 // Coord values for non-cartesian coordinate systems are functions of the locations of the
2921 // quadrature points in physical space. We also have no way of knowing whether this was called
2922 // from a volumetric or face object so we should set both volumetric and face xyz to true
2923 _calculate_xyz = true;
2924 _calculate_face_xyz = true;
2925 _need_ad_volume_map = true;
2926 _need_ad_face_map = true;
2927
2928 _calculate_ad_coord = true;
2929 return _ad_coord;
2930}
bool _need_ad_volume_map
Whether any object needs the AD element JxW, quadrature points or coordinate transformation.
Definition Assembly.h:2794
bool _need_ad_face_map
Whether any object needs the AD face JxW, normals, quadrature points, curvatures or coordinate transf...
Definition Assembly.h:2797

◆ adCurvatures()

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

Definition at line 4857 of file Assembly.C.

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

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

3867{
3868#ifndef NDEBUG
3870 {
3871 mooseAssert(_cached_jacobian_rows.size() == _cached_jacobian_cols.size(),
3872 "Error: Cached data sizes MUST be the same!");
3873 for (MooseIndex(_cached_jacobian_rows) i = 0; i < _cached_jacobian_rows.size(); i++)
3874 mooseAssert(_cached_jacobian_rows[i].size() == _cached_jacobian_cols[i].size(),
3875 "Error: Cached data sizes MUST be the same for a given tag!");
3876 }
3877#endif
3878
3879 for (MooseIndex(_cached_jacobian_rows) i = 0; i < _cached_jacobian_rows.size(); i++)
3880 if (_sys.hasMatrix(i))
3881 for (MooseIndex(_cached_jacobian_rows[i]) j = 0; j < _cached_jacobian_rows[i].size(); j++)
3885
3886 for (MooseIndex(_cached_jacobian_rows) i = 0; i < _cached_jacobian_rows.size(); i++)
3887 {
3888 if (!_sys.hasMatrix(i))
3889 continue;
3890
3893
3894 // Try to be more efficient from now on
3895 // The 2 is just a fudge factor to keep us from having to grow the vector during assembly
3896 _cached_jacobian_values[i].clear();
3898
3899 _cached_jacobian_rows[i].clear();
3901
3902 _cached_jacobian_cols[i].clear();
3904 }
3905}
std::vector< std::vector< dof_id_type > > _cached_jacobian_cols
Column where the corresponding cached value should go.
Definition Assembly.h:2823
std::vector< std::vector< dof_id_type > > _cached_jacobian_rows
Row where the corresponding cached value should go.
Definition Assembly.h:2821
std::vector< std::vector< Real > > _cached_jacobian_values
Values cached by calling cacheJacobian()
Definition Assembly.h:2819
virtual bool checkNonlocalCouplingRequirement() const =0
virtual libMesh::SparseMatrix< Number > & getMatrix(TagID tag)
Get a raw SparseMatrix.
virtual bool hasMatrix(TagID tag) const
Check if the tagged matrix exists in the system.
Definition SystemBase.h:391
virtual void add(const numeric_index_type i, const numeric_index_type j, const T value)=0

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

3584{
3585 const auto & values = _cached_residual_values[vector_tag._type_id];
3586 const auto & rows = _cached_residual_rows[vector_tag._type_id];
3587
3588 mooseAssert(values.size() == rows.size(),
3589 "Number of cached residuals and number of rows must match!");
3590
3591 if (!values.empty())
3592 {
3593 residual.add_vector(values, rows);
3594 clearCachedResiduals(vector_tag);
3595 }
3596}
std::array< Real, 2 > values
Definition MortarUtils.C:52
void clearCachedResiduals(GlobalDataKey)
Clears all of the residuals in _cached_residual_rows and _cached_residual_values.
Definition Assembly.C:3551
TagTypeID _type_id
The index for this tag into a vector that contains tags of only its type ordered by ID.
Definition VectorTag.h:47
virtual void add_vector(const T *v, const std::vector< numeric_index_type > &dof_indices)

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

3537{
3538 for (const auto & vector_tag : tags)
3539 {
3540 if (!_sys.hasVector(vector_tag._id))
3541 {
3542 _cached_residual_values[vector_tag._type_id].clear();
3543 _cached_residual_rows[vector_tag._type_id].clear();
3544 continue;
3545 }
3546 addCachedResidualDirectly(_sys.getVector(vector_tag._id), GlobalDataKey{}, vector_tag);
3547 }
3548}
void addCachedResidualDirectly(NumericVector< Number > &residual, GlobalDataKey, const VectorTag &vector_tag)
Adds the values that have been cached by calling cacheResidual(), cacheResidualNeighbor(),...
Definition Assembly.C:3581
bool hasVector(const std::string &tag_name) const
Check if the named vector exists in the system.
Definition SystemBase.C:924
virtual NumericVector< Number > & getVector(const std::string &name)
Get a raw NumericVector by name.
Definition SystemBase.C:933

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

◆ addJacobian()

void Assembly::addJacobian ( GlobalDataKey  )

Adds all local Jacobian to the global Jacobian matrices.

Definition at line 3923 of file Assembly.C.

3924{
3925 for (const auto & it : _cm_ff_entry)
3926 addJacobianCoupledVarPair(*it.first, *it.second);
3927
3928 for (const auto & it : _cm_sf_entry)
3929 addJacobianCoupledVarPair(*it.first, *it.second);
3930
3931 for (const auto & it : _cm_fs_entry)
3932 addJacobianCoupledVarPair(*it.first, *it.second);
3933}
std::vector< std::pair< MooseVariableScalar *, MooseVariableFieldBase * > > _cm_sf_entry
Entries in the coupling matrix for scalar variables vs field variables.
Definition Assembly.h:2334
std::vector< std::pair< MooseVariableFieldBase *, MooseVariableFieldBase * > > _cm_ff_entry
Entries in the coupling matrix for field variables.
Definition Assembly.h:2330
void addJacobianCoupledVarPair(const MooseVariableBase &ivar, const MooseVariableBase &jvar)
Adds element matrices for ivar rows and jvar columns to the global Jacobian matrices.
Definition Assembly.C:3908
std::vector< std::pair< MooseVariableFieldBase *, MooseVariableScalar * > > _cm_fs_entry
Entries in the coupling matrix for field variables vs scalar variables.
Definition Assembly.h:2332

◆ addJacobianBlock() [1/2]

void Assembly::addJacobianBlock ( libMesh::SparseMatrix< Number > &  jacobian,
DenseMatrix< Number > &  jac_block,
const MooseVariableBase &  ivar,
const MooseVariableBase &  jvar,
const std::vector< dof_id_type > &  idof_indices,
const std::vector< dof_id_type > &  jdof_indices 
)
private

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

Definition at line 3621 of file Assembly.C.

3627{
3628 if (idof_indices.size() == 0 || jdof_indices.size() == 0)
3629 return;
3630 if (jac_block.n() == 0 || jac_block.m() == 0)
3631 return;
3632
3633 const auto & scaling_factors = ivar.arrayScalingFactor();
3634 const unsigned int iv = ivar.number();
3635 const unsigned int jv = jvar.number();
3636
3637 for (unsigned int i = 0; i < ivar.count(); ++i)
3638 {
3639 for (const auto & jt : libMesh::ConstCouplingRow(iv + i, *_cm))
3640 {
3641 if (jt < jv || jt >= jv + jvar.count())
3642 continue;
3643 unsigned int j = jt - jv;
3644
3645 auto di = ivar.componentDofIndices(idof_indices, i);
3646 auto dj = jvar.componentDofIndices(jdof_indices, j);
3647 auto indof = di.size();
3648 auto jndof = dj.size();
3649
3650 unsigned int jj = j;
3651 if (iv == jv && _component_block_diagonal[iv])
3652 // here i must be equal to j
3653 jj = 0;
3654
3655 auto sub = jac_block.sub_matrix(i * indof, indof, jj * jndof, jndof);
3656 if (scaling_factors[i] != 1.0)
3657 sub *= scaling_factors[i];
3658
3659 // If we're computing the jacobian for automatically scaling variables we do not want
3660 // to constrain the element matrix because it introduces 1s on the diagonal for the
3661 // constrained dofs
3663 _dof_map.constrain_element_matrix(sub, di, dj, false);
3664
3665 jacobian.add_matrix(sub, di, dj);
3666 }
3667 }
3668}
std::vector< bool > _component_block_diagonal
An flag array Indiced by variable index to show if there is no component-wise coupling for the variab...
Definition Assembly.h:2831
const libMesh::CouplingMatrix * _cm
Coupling matrices.
Definition Assembly.h:2317
std::vector< dof_id_type > componentDofIndices(const std::vector< dof_id_type > &dof_indices, unsigned int component) const
Obtain DoF indices of a component with the indices of the 0th component.
const std::vector< Real > & arrayScalingFactor() const
unsigned int number() const
Get variable number coming from libMesh.
unsigned int count() const
Get the number of components Note: For standard and vector variables, the number is one.
bool computingScalingJacobian() const
Whether we are computing an initial Jacobian for automatic variable scaling.
unsigned int n() const
unsigned int m() const
DenseMatrix sub_matrix(unsigned int row_id, unsigned int row_size, unsigned int col_id, unsigned int col_size) const
void constrain_element_matrix(DenseMatrix< Number > &matrix, std::vector< dof_id_type > &elem_dofs, bool asymmetric_constraint_rows=true) const
virtual void add_matrix(const DenseMatrix< T > &dm, const std::vector< numeric_index_type > &rows, const std::vector< numeric_index_type > &cols)=0
The following methods are specializations for using the libMesh::Parallel::packed_range_* routines fo...

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

4357{
4358 if (idof_indices.size() == 0 || jdof_indices.size() == 0)
4359 return;
4360 if (jacobian.n() == 0 || jacobian.m() == 0)
4361 return;
4362 if (!(*_cm)(ivar, jvar))
4363 return;
4364
4365 auto & iv = _sys.getVariable(_tid, ivar);
4366 auto & jv = _sys.getVariable(_tid, jvar);
4367 auto & scaling_factor = iv.arrayScalingFactor();
4368
4369 const unsigned int ivn = iv.number();
4370 const unsigned int jvn = jv.number();
4371 auto & keg = jacobianBlockNonlocal(ivn, jvn, LocalDataKey{}, tag);
4372
4373 // It is guaranteed by design iv.number <= ivar since iv is obtained
4374 // through SystemBase::getVariable with ivar.
4375 // Most of times ivar will just be equal to iv.number except for array variables,
4376 // where ivar could be a number for a component of an array variable but calling
4377 // getVariable will return the array variable that has the number of the 0th component.
4378 // It is the same for jvar.
4379 const unsigned int i = ivar - ivn;
4380 const unsigned int j = jvar - jvn;
4381
4382 // DoF indices are independently given
4383 auto di = idof_indices;
4384 auto dj = jdof_indices;
4385
4386 auto indof = di.size();
4387 auto jndof = dj.size();
4388
4389 unsigned int jj = j;
4390 if (ivar == jvar && _component_block_diagonal[ivn])
4391 jj = 0;
4392
4393 auto sub = keg.sub_matrix(i * indof, indof, jj * jndof, jndof);
4394 // If we're computing the jacobian for automatically scaling variables we do not want to
4395 // constrain the element matrix because it introduces 1s on the diagonal for the constrained
4396 // dofs
4398 dof_map.constrain_element_matrix(sub, di, dj, false);
4399
4400 if (scaling_factor[i] != 1.0)
4401 sub *= scaling_factor[i];
4402
4403 jacobian.add_matrix(sub, di, dj);
4404}
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.
Definition Assembly.h:1149
MooseVariableFieldBase & getVariable(THREAD_ID tid, const std::string &var_name) const
Gets a reference to a variable of with specified name.
Definition SystemBase.C:92
virtual numeric_index_type n() const=0
virtual numeric_index_type m() const=0

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

4415{
4416 for (auto tag : tags)
4418 jacobian, ivar, jvar, dof_map, idof_indices, jdof_indices, GlobalDataKey{}, tag);
4419}
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.
Definition Assembly.C:4349

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

4288{
4289 for (auto tag : tags)
4290 addJacobianBlock(jacobian, ivar, jvar, dof_map, dof_indices, GlobalDataKey{}, tag);
4291}
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.

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

3909{
3910 auto i = ivar.number();
3911 auto j = jvar.number();
3912 for (MooseIndex(_jacobian_block_used) tag = 0; tag < _jacobian_block_used.size(); tag++)
3913 if (jacobianBlockUsed(tag, i, j) && _sys.hasMatrix(tag))
3915 jacobianBlock(i, j, LocalDataKey{}, tag),
3916 ivar,
3917 jvar,
3918 ivar.dofIndices(),
3919 jvar.dofIndices());
3920}
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.
Definition Assembly.h:2238
DenseMatrix< Number > & jacobianBlock(unsigned int ivar, unsigned int jvar, LocalDataKey, TagID tag)
Get local Jacobian block for a pair of variables and a tag.
Definition Assembly.h:1138
std::vector< std::vector< std::vector< unsigned char > > > _jacobian_block_used
Flag that indicates if the jacobian block was used.
Definition Assembly.h:2340
virtual const std::vector< dof_id_type > & dofIndices() const
Get local DoF indices.

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

4075{
4076 for (const auto & it : _cm_ff_entry)
4077 {
4078 auto ivar = it.first;
4079 auto jvar = it.second;
4080 auto i = ivar->number();
4081 auto j = jvar->number();
4082 for (MooseIndex(_jacobian_block_lower_used) tag = 0; tag < _jacobian_block_lower_used.size();
4083 tag++)
4084 if (jacobianBlockLowerUsed(tag, i, j) && _sys.hasMatrix(tag))
4085 {
4087 jacobianBlockMortar(Moose::LowerLower, i, j, LocalDataKey{}, tag),
4088 *ivar,
4089 *jvar,
4090 ivar->dofIndicesLower(),
4091 jvar->dofIndicesLower());
4092
4094 jacobianBlockMortar(Moose::LowerSecondary, i, j, LocalDataKey{}, tag),
4095 *ivar,
4096 *jvar,
4097 ivar->dofIndicesLower(),
4098 jvar->dofIndices());
4099
4101 jacobianBlockMortar(Moose::SecondaryLower, i, j, LocalDataKey{}, tag),
4102 *ivar,
4103 *jvar,
4104 ivar->dofIndices(),
4105 jvar->dofIndicesLower());
4106 }
4107 }
4108}
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.
Definition Assembly.h:2274
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.
Definition Assembly.C:3227
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.
Definition Assembly.h:2345
@ LowerLower
Definition MooseTypes.h:860
@ LowerSecondary
Definition MooseTypes.h:861
@ SecondaryLower
Definition MooseTypes.h:863

◆ addJacobianNeighbor() [1/2]

void Assembly::addJacobianNeighbor ( GlobalDataKey  )

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

Definition at line 3958 of file Assembly.C.

3959{
3960 for (const auto & it : _cm_ff_entry)
3961 {
3962 auto ivar = it.first;
3963 auto jvar = it.second;
3964 auto i = ivar->number();
3965 auto j = jvar->number();
3966 for (MooseIndex(_jacobian_block_neighbor_used) tag = 0;
3967 tag < _jacobian_block_neighbor_used.size();
3968 tag++)
3969 if (jacobianBlockNeighborUsed(tag, i, j) && _sys.hasMatrix(tag))
3970 {
3972 jacobianBlockNeighbor(Moose::ElementNeighbor, i, j, LocalDataKey{}, tag),
3973 *ivar,
3974 *jvar,
3975 ivar->dofIndices(),
3976 jvar->dofIndicesNeighbor());
3977
3979 jacobianBlockNeighbor(Moose::NeighborElement, i, j, LocalDataKey{}, tag),
3980 *ivar,
3981 *jvar,
3982 ivar->dofIndicesNeighbor(),
3983 jvar->dofIndices());
3984
3986 jacobianBlockNeighbor(Moose::NeighborNeighbor, i, j, LocalDataKey{}, tag),
3987 *ivar,
3988 *jvar,
3989 ivar->dofIndicesNeighbor(),
3990 jvar->dofIndicesNeighbor());
3991 }
3992 }
3993}
std::vector< std::vector< std::vector< unsigned char > > > _jacobian_block_neighbor_used
Flag that indicates if the jacobian block for neighbor was used.
Definition Assembly.h:2343
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.
Definition Assembly.C:3186
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.
Definition Assembly.h:2256
@ NeighborNeighbor
Definition MooseTypes.h:812
@ NeighborElement
Definition MooseTypes.h:811
@ ElementNeighbor
Definition MooseTypes.h:810

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

3997{
3998 for (const auto & it : _cm_ff_entry)
3999 {
4000 auto ivar = it.first;
4001 auto jvar = it.second;
4002 auto i = ivar->number();
4003 auto j = jvar->number();
4004 for (MooseIndex(_jacobian_block_lower_used) tag = 0; tag < _jacobian_block_lower_used.size();
4005 tag++)
4006 if (jacobianBlockLowerUsed(tag, i, j) && _sys.hasMatrix(tag))
4007 {
4009 jacobianBlockMortar(Moose::LowerLower, i, j, LocalDataKey{}, tag),
4010 *ivar,
4011 *jvar,
4012 ivar->dofIndicesLower(),
4013 jvar->dofIndicesLower());
4014
4016 jacobianBlockMortar(Moose::LowerSecondary, i, j, LocalDataKey{}, tag),
4017 *ivar,
4018 *jvar,
4019 ivar->dofIndicesLower(),
4020 jvar->dofIndicesNeighbor());
4021
4023 jacobianBlockMortar(Moose::LowerPrimary, i, j, LocalDataKey{}, tag),
4024 *ivar,
4025 *jvar,
4026 ivar->dofIndicesLower(),
4027 jvar->dofIndices());
4028
4030 jacobianBlockMortar(Moose::SecondaryLower, i, j, LocalDataKey{}, tag),
4031 *ivar,
4032 *jvar,
4033 ivar->dofIndicesNeighbor(),
4034 jvar->dofIndicesLower());
4035
4037 jacobianBlockMortar(Moose::PrimaryLower, i, j, LocalDataKey{}, tag),
4038 *ivar,
4039 *jvar,
4040 ivar->dofIndices(),
4041 jvar->dofIndicesLower());
4042 }
4043
4044 for (MooseIndex(_jacobian_block_neighbor_used) tag = 0;
4045 tag < _jacobian_block_neighbor_used.size();
4046 tag++)
4047 if (jacobianBlockNeighborUsed(tag, i, j) && _sys.hasMatrix(tag))
4048 {
4050 jacobianBlockNeighbor(Moose::ElementNeighbor, i, j, LocalDataKey{}, tag),
4051 *ivar,
4052 *jvar,
4053 ivar->dofIndices(),
4054 jvar->dofIndicesNeighbor());
4055
4057 jacobianBlockNeighbor(Moose::NeighborElement, i, j, LocalDataKey{}, tag),
4058 *ivar,
4059 *jvar,
4060 ivar->dofIndicesNeighbor(),
4061 jvar->dofIndices());
4062
4064 jacobianBlockNeighbor(Moose::NeighborNeighbor, i, j, LocalDataKey{}, tag),
4065 *ivar,
4066 *jvar,
4067 ivar->dofIndicesNeighbor(),
4068 jvar->dofIndicesNeighbor());
4069 }
4070 }
4071}
@ PrimaryLower
Definition MooseTypes.h:864
@ LowerPrimary
Definition MooseTypes.h:862

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

4499{
4500 for (const auto tag : tags)
4502 jacobian, ivar, jvar, dof_map, dof_indices, neighbor_dof_indices, GlobalDataKey{}, tag);
4503}
void addJacobianNeighbor(GlobalDataKey)
Add ElementNeighbor, NeighborElement, and NeighborNeighbor portions of the Jacobian for compute objec...
Definition Assembly.C:3958

◆ addJacobianNonlocal()

void Assembly::addJacobianNonlocal ( GlobalDataKey  )

Adds non-local Jacobian to the global Jacobian matrices.

Definition at line 3936 of file Assembly.C.

3937{
3938 for (const auto & it : _cm_nonlocal_entry)
3939 {
3940 auto ivar = it.first;
3941 auto jvar = it.second;
3942 auto i = ivar->number();
3943 auto j = jvar->number();
3944 for (MooseIndex(_jacobian_block_nonlocal_used) tag = 0;
3945 tag < _jacobian_block_nonlocal_used.size();
3946 tag++)
3947 if (jacobianBlockNonlocalUsed(tag, i, j) && _sys.hasMatrix(tag))
3949 jacobianBlockNonlocal(i, j, LocalDataKey{}, tag),
3950 *ivar,
3951 *jvar,
3952 ivar->dofIndices(),
3953 jvar->allDofIndices());
3954 }
3955}
std::vector< std::pair< MooseVariableFieldBase *, MooseVariableFieldBase * > > _cm_nonlocal_entry
Entries in the coupling matrix for field variables for nonlocal calculations.
Definition Assembly.h:2338
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.
Definition Assembly.h:2292
std::vector< std::vector< std::vector< unsigned char > > > _jacobian_block_nonlocal_used
Definition Assembly.h:2341

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

4514{
4515 for (const auto & it : _cm_sf_entry)
4516 if (it.first->number() == ivar)
4517 addJacobianCoupledVarPair(*it.first, *it.second);
4518}
if(!dmm->_nl) SETERRQ(PETSC_COMM_WORLD

◆ addJacobianScalar()

void Assembly::addJacobianScalar ( GlobalDataKey  )

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

Definition at line 4506 of file Assembly.C.

4507{
4508 for (const auto & it : _cm_ss_entry)
4509 addJacobianCoupledVarPair(*it.first, *it.second);
4510}
std::vector< std::pair< MooseVariableScalar *, MooseVariableScalar * > > _cm_ss_entry
Entries in the coupling matrix for scalar variables.
Definition Assembly.h:2336

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

3371{
3372 mooseAssert(vector_tag._type == Moose::VECTOR_TAG_RESIDUAL,
3373 "Non-residual tag in Assembly::addResidual");
3374
3375 auto & tag_Re = _sub_Re[vector_tag._type_id];
3376 NumericVector<Number> & residual = _sys.getVector(vector_tag._id);
3377 const std::vector<MooseVariableFEBase *> & vars = _sys.getVariables(_tid);
3378 for (const auto & var : vars)
3379 addResidualBlock(residual, tag_Re[var->number()], var->dofIndices(), var->arrayScalingFactor());
3380}
char ** vars
std::vector< std::vector< DenseVector< Number > > > _sub_Re
Definition Assembly.h:2659
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.
Definition Assembly.C:3317
const std::vector< MooseVariableFieldBase * > & getVariables(THREAD_ID tid)
Definition SystemBase.h:782
TagID _id
The id associated with the vector tag.
Definition VectorTag.h:30
Moose::VectorTagType _type
The type of the vector tag.
Definition VectorTag.h:53

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

3384{
3385 for (const auto & vector_tag : vector_tags)
3386 if (_sys.hasVector(vector_tag._id))
3387 addResidual(vector_tag);
3388}
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 associa...
Definition Assembly.C:3383

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

3321{
3322 if (dof_indices.size() > 0 && res_block.size())
3323 {
3324 _temp_dof_indices = dof_indices;
3325 _tmp_Re = res_block;
3328 }
3329}
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 ...
Definition Assembly.C:3287
DenseVector< Number > _tmp_Re
auxiliary vector for scaling residuals (optimization to avoid expensive construction/destruction)
Definition Assembly.h:2665
std::vector< dof_id_type > _temp_dof_indices
Temporary work vector to keep from reallocating it.
Definition Assembly.h:2834
virtual unsigned int size() const override final

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

3414{
3415 mooseAssert(vector_tag._type == Moose::VECTOR_TAG_RESIDUAL,
3416 "Non-residual tag in Assembly::addResidualLower");
3417
3418 auto & tag_Rl = _sub_Rl[vector_tag._type_id];
3419 NumericVector<Number> & residual = _sys.getVector(vector_tag._id);
3420 const std::vector<MooseVariableFEBase *> & vars = _sys.getVariables(_tid);
3421 for (const auto & var : vars)
3423 residual, tag_Rl[var->number()], var->dofIndicesLower(), var->arrayScalingFactor());
3424}
std::vector< std::vector< DenseVector< Number > > > _sub_Rl
residual contributions for each variable from the lower dimensional element
Definition Assembly.h:2662

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

3428{
3429 for (const auto & vector_tag : vector_tags)
3430 if (_sys.hasVector(vector_tag._id))
3431 addResidualLower(vector_tag);
3432}
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 vector...
Definition Assembly.C:3427

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

3392{
3393 mooseAssert(vector_tag._type == Moose::VECTOR_TAG_RESIDUAL,
3394 "Non-residual tag in Assembly::addResidualNeighbor");
3395
3396 auto & tag_Rn = _sub_Rn[vector_tag._type_id];
3397 NumericVector<Number> & residual = _sys.getVector(vector_tag._id);
3398 const std::vector<MooseVariableFEBase *> & vars = _sys.getVariables(_tid);
3399 for (const auto & var : vars)
3401 residual, tag_Rn[var->number()], var->dofIndicesNeighbor(), var->arrayScalingFactor());
3402}
std::vector< std::vector< DenseVector< Number > > > _sub_Rn
Definition Assembly.h:2660

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

3406{
3407 for (const auto & vector_tag : vector_tags)
3408 if (_sys.hasVector(vector_tag._id))
3409 addResidualNeighbor(vector_tag);
3410}
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 vector...
Definition Assembly.C:3405

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

3437{
3438 mooseAssert(vector_tag._type == Moose::VECTOR_TAG_RESIDUAL,
3439 "Non-residual tag in Assembly::addResidualScalar");
3440
3441 // add the scalar variables residuals
3442 auto & tag_Re = _sub_Re[vector_tag._type_id];
3443 NumericVector<Number> & residual = _sys.getVector(vector_tag._id);
3444 const std::vector<MooseVariableScalar *> & vars = _sys.getScalarVariables(_tid);
3445 for (const auto & var : vars)
3446 addResidualBlock(residual, tag_Re[var->number()], var->dofIndices(), var->arrayScalingFactor());
3447}
const std::vector< MooseVariableScalar * > & getScalarVariables(THREAD_ID tid)
Definition SystemBase.h:789

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

3451{
3452 for (const auto & vector_tag : vector_tags)
3453 if (_sys.hasVector(vector_tag._id))
3454 addResidualScalar(vector_tag);
3455}
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 w...
Definition Assembly.C:3450

Referenced by addResidualScalar().

◆ adGradPhi() [1/2]

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

Definition at line 3075 of file Assembly.h.

3077{
3078 _need_ad_grad_phi = true;
3079 return _ad_vector_grad_phi_data.at(v.feType());
3080}
bool _need_ad_grad_phi
Whether any object needs the AD element shape function gradients.
Definition Assembly.h:2789
const libMesh::FEType & feType() const
Get the type of finite element object.

◆ adGradPhi() [2/2]

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

Definition at line 1318 of file Assembly.h.

1319 {
1320 _need_ad_grad_phi = true;
1321 return _ad_grad_phi_data.at(v.feType());
1322 }

◆ adJxW()

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

Definition at line 270 of file Assembly.h.

271 {
272 _need_ad_volume_map = true;
273 return _ad_JxW;
274 }

◆ adJxWFace()

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

Definition at line 276 of file Assembly.h.

277 {
278 _need_ad_face_map = true;
279 return _ad_JxW_face;
280 }

◆ adNormals()

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

Definition at line 383 of file Assembly.h.

384 {
385 _need_ad_face_map = true;
386 return _ad_normals;
387 }

◆ adQPoints()

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

Definition at line 389 of file Assembly.h.

390 {
391 _calculate_xyz = true;
392 _need_ad_volume_map = true;
393 return _ad_q_points;
394 }

Referenced by genericQPoints().

◆ adQPointsFace()

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

Definition at line 396 of file Assembly.h.

397 {
398 _calculate_face_xyz = true;
399 _need_ad_face_map = true;
400 return _ad_q_points_face;
401 }

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

3257{
3258 _disp_numbers_and_directions = std::move(disp_numbers_and_directions);
3259}
std::vector< std::pair< unsigned int, unsigned short > > _disp_numbers_and_directions
Container of displacement numbers and directions.
Definition Assembly.h:2868

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

1918 {
1919 auto qrule = qrules(dim).vol.get();
1920 fe.attach_quadrature_rule(qrule);
1921 return qrule;
1922 }
QRules & qrules(unsigned int dim)
Definition Assembly.h:2489
std::unique_ptr< libMesh::QBase > vol
volume/elem (meshdim) quadrature rule
Definition Assembly.h:2441

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

1930 {
1931 auto qrule = qrules(dim).face.get();
1932 fe.attach_quadrature_rule(qrule);
1933 return qrule;
1934 }
std::unique_ptr< libMesh::QBase > face
area/face (meshdim-1) quadrature rule
Definition Assembly.h:2443

◆ buildFaceFE()

void Assembly::buildFaceFE ( FEType  type) const
private

Build FEs for a face with a type.

Parameters
typeThe type of FE

Definition at line 296 of file Assembly.C.

297{
298 if (!_building_helpers && type == _helper_type)
300
301 if (!_fe_shape_data_face[type])
302 _fe_shape_data_face[type] = std::make_unique<FEShapeData>();
303
304 // Build an FE object for this type for each dimension up to the dimension of the current mesh
305 for (unsigned int dim = 0; dim <= _mesh_dimension; dim++)
306 {
307 if (!_fe_face[dim][type])
308 {
309 _fe_face[dim][type] = FEGenericBase<Real>::build(dim, type).release();
310 _fe_face[dim][type]->add_p_level_in_reinit(type.p_refinement);
311 }
312
313 _fe_face[dim][type]->get_phi();
314 _fe_face[dim][type]->get_dphi();
315 if (_need_second_derivative.count(type))
316 _fe_face[dim][type]->get_d2phi();
317 }
318}
std::set< FEType > _need_second_derivative
Definition Assembly.h:2878
std::map< FEType, std::unique_ptr< FEShapeData > > _fe_shape_data_face
Definition Assembly.h:2765

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
typeThe type of FE

Definition at line 346 of file Assembly.C.

347{
348 if (!_building_helpers && type == _helper_type)
350
352 _fe_shape_data_face_neighbor[type] = std::make_unique<FEShapeData>();
353
354 // Build an FE object for this type for each dimension up to the dimension of the current mesh
355 for (unsigned int dim = 0; dim <= _mesh_dimension; dim++)
356 {
357 if (!_fe_face_neighbor[dim][type])
358 {
359 _fe_face_neighbor[dim][type] = FEGenericBase<Real>::build(dim, type).release();
360 _fe_face_neighbor[dim][type]->add_p_level_in_reinit(type.p_refinement);
361 }
362
363 _fe_face_neighbor[dim][type]->get_phi();
364 _fe_face_neighbor[dim][type]->get_dphi();
365 if (_need_second_derivative_neighbor.count(type))
366 _fe_face_neighbor[dim][type]->get_d2phi();
367 }
368}
std::set< FEType > _need_second_derivative_neighbor
Definition Assembly.h:2879
std::map< FEType, std::unique_ptr< FEShapeData > > _fe_shape_data_face_neighbor
Definition Assembly.h:2767

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

◆ buildFE()

void Assembly::buildFE ( FEType  type) const
private

Build FEs with a type.

Parameters
typeThe type of FE

Definition at line 267 of file Assembly.C.

268{
269 if (!_building_helpers && type == _helper_type)
271
272 if (!_fe_shape_data[type])
273 _fe_shape_data[type] = std::make_unique<FEShapeData>();
274
275 // Build an FE object for this type for each dimension up to the dimension of the current mesh
276 for (unsigned int dim = 0; dim <= _mesh_dimension; dim++)
277 {
278 if (!_fe[dim][type])
279 {
280 _fe[dim][type] = FEGenericBase<Real>::build(dim, type).release();
281 _fe[dim][type]->add_p_level_in_reinit(type.p_refinement);
282 }
283
284 _fe[dim][type]->get_phi();
285 _fe[dim][type]->get_dphi();
286 // Pre-request xyz. We have always computed xyz, but due to
287 // recent optimizations in libmesh, we now need to explicity
288 // request it, since apps (Yak) may rely on it being computed.
289 _fe[dim][type]->get_xyz();
290 if (_need_second_derivative.count(type))
291 _fe[dim][type]->get_d2phi();
292 }
293}
std::map< FEType, std::unique_ptr< FEShapeData > > _fe_shape_data
Shape function values, gradients, second derivatives for each FE type.
Definition Assembly.h:2764

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

◆ buildLowerDDualFE()

void Assembly::buildLowerDDualFE ( FEType  type) const
private

Definition at line 398 of file Assembly.C.

399{
400 if (!_fe_shape_data_dual_lower[type])
401 _fe_shape_data_dual_lower[type] = std::make_unique<FEShapeData>();
402
403 // Build an FE object for this type for each dimension up to the dimension of
404 // the current mesh minus one (because this is for lower-dimensional
405 // elements!)
406 for (unsigned int dim = 0; dim <= _mesh_dimension - 1; dim++)
407 {
408 if (!_fe_lower[dim][type])
409 {
410 _fe_lower[dim][type] = FEGenericBase<Real>::build(dim, type).release();
411 _fe_lower[dim][type]->add_p_level_in_reinit(type.p_refinement);
412 }
413
414 _fe_lower[dim][type]->get_dual_phi();
415 _fe_lower[dim][type]->get_dual_dphi();
416 if (_need_second_derivative.count(type))
417 _fe_lower[dim][type]->get_dual_d2phi();
418 }
419}
std::map< FEType, std::unique_ptr< FEShapeData > > _fe_shape_data_dual_lower
Definition Assembly.h:2769

Referenced by feDualPhiLower(), and feGradDualPhiLower().

◆ buildLowerDFE()

void Assembly::buildLowerDFE ( FEType  type) const
private

Build FEs for a lower dimensional element with a type.

Parameters
typeThe type of FE

Definition at line 371 of file Assembly.C.

372{
373 if (!_building_helpers && type == _helper_type)
375
376 if (!_fe_shape_data_lower[type])
377 _fe_shape_data_lower[type] = std::make_unique<FEShapeData>();
378
379 // Build an FE object for this type for each dimension up to the dimension of
380 // the current mesh minus one (because this is for lower-dimensional
381 // elements!)
382 for (unsigned int dim = 0; dim <= _mesh_dimension - 1; dim++)
383 {
384 if (!_fe_lower[dim][type])
385 {
386 _fe_lower[dim][type] = FEGenericBase<Real>::build(dim, type).release();
387 _fe_lower[dim][type]->add_p_level_in_reinit(type.p_refinement);
388 }
389
390 _fe_lower[dim][type]->get_phi();
391 _fe_lower[dim][type]->get_dphi();
392 if (_need_second_derivative.count(type))
393 _fe_lower[dim][type]->get_d2phi();
394 }
395}
std::map< FEType, std::unique_ptr< FEShapeData > > _fe_shape_data_lower
Definition Assembly.h:2768

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

◆ buildNeighborFE()

void Assembly::buildNeighborFE ( FEType  type) const
private

Build FEs for a neighbor with a type.

Parameters
typeThe type of FE

Definition at line 321 of file Assembly.C.

322{
323 if (!_building_helpers && type == _helper_type)
325
326 if (!_fe_shape_data_neighbor[type])
327 _fe_shape_data_neighbor[type] = std::make_unique<FEShapeData>();
328
329 // Build an FE object for this type for each dimension up to the dimension of the current mesh
330 for (unsigned int dim = 0; dim <= _mesh_dimension; dim++)
331 {
332 if (!_fe_neighbor[dim][type])
333 {
334 _fe_neighbor[dim][type] = FEGenericBase<Real>::build(dim, type).release();
335 _fe_neighbor[dim][type]->add_p_level_in_reinit(type.p_refinement);
336 }
337
338 _fe_neighbor[dim][type]->get_phi();
339 _fe_neighbor[dim][type]->get_dphi();
340 if (_need_second_derivative_neighbor.count(type))
341 _fe_neighbor[dim][type]->get_d2phi();
342 }
343}
std::map< FEType, std::unique_ptr< FEShapeData > > _fe_shape_data_neighbor
Definition Assembly.h:2766

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

◆ buildVectorDualLowerDFE()

void Assembly::buildVectorDualLowerDFE ( FEType  type) const
private

Definition at line 450 of file Assembly.C.

451{
453 _vector_fe_shape_data_dual_lower[type] = std::make_unique<VectorFEShapeData>();
454
455 // Build an FE object for this type for each dimension up to the dimension of
456 // the current mesh minus one (because this is for lower-dimensional
457 // elements!)
458 unsigned int dim = ((type.family == LAGRANGE_VEC) || (type.family == MONOMIAL_VEC)) ? 0 : 2;
459 const auto ending_dim = cast_int<unsigned int>(_mesh_dimension - 1);
460 if (ending_dim < dim)
461 return;
462 for (; dim <= ending_dim; dim++)
463 {
464 if (!_vector_fe_lower[dim][type])
465 {
466 _vector_fe_lower[dim][type] = FEVectorBase::build(dim, type).release();
467 _vector_fe_lower[dim][type]->add_p_level_in_reinit(type.p_refinement);
468 }
469
470 _vector_fe_lower[dim][type]->get_dual_phi();
471 _vector_fe_lower[dim][type]->get_dual_dphi();
472 if (_need_second_derivative.count(type))
473 _vector_fe_lower[dim][type]->get_dual_d2phi();
474 }
475}
std::map< FEType, std::unique_ptr< VectorFEShapeData > > _vector_fe_shape_data_dual_lower
Definition Assembly.h:2777

◆ buildVectorFaceFE()

void Assembly::buildVectorFaceFE ( FEType  type) const
private

Build Vector FEs for a face with a type.

Parameters
typeThe type of FE

Definition at line 512 of file Assembly.C.

513{
515 _vector_fe_shape_data_face[type] = std::make_unique<VectorFEShapeData>();
516
517 // Note that NEDELEC_ONE and RAVIART_THOMAS elements can only be built for dimension > 2
518 unsigned int min_dim;
519 if (type.family == NEDELEC_ONE || type.family == RAVIART_THOMAS ||
520 type.family == L2_RAVIART_THOMAS)
521 min_dim = 2;
522 else
523 min_dim = 0;
524
525 // Build an FE object for this type for each dimension from the min_dim up to the dimension of the
526 // current mesh
527 for (unsigned int dim = min_dim; dim <= _mesh_dimension; dim++)
528 {
529 if (!_vector_fe_face[dim][type])
530 {
531 _vector_fe_face[dim][type] = FEGenericBase<VectorValue<Real>>::build(dim, type).release();
532 _vector_fe_face[dim][type]->add_p_level_in_reinit(type.p_refinement);
533 }
534
535 _vector_fe_face[dim][type]->get_phi();
536 _vector_fe_face[dim][type]->get_dphi();
537 if (_need_curl.count(type))
538 _vector_fe_face[dim][type]->get_curl_phi();
539 if (_need_face_div.count(type))
540 _vector_fe_face[dim][type]->get_div_phi();
541 }
542}
std::map< FEType, std::unique_ptr< VectorFEShapeData > > _vector_fe_shape_data_face
Definition Assembly.h:2773
std::set< FEType > _need_curl
Definition Assembly.h:2880
std::set< FEType > _need_face_div
Definition Assembly.h:2882

Referenced by getVectorFEFace().

◆ buildVectorFaceNeighborFE()

void Assembly::buildVectorFaceNeighborFE ( FEType  type) const
private

Build Vector FEs for a neighbor face with a type.

Parameters
typeThe type of FE

Definition at line 578 of file Assembly.C.

579{
581 _vector_fe_shape_data_face_neighbor[type] = std::make_unique<VectorFEShapeData>();
582
583 // Note that NEDELEC_ONE and RAVIART_THOMAS elements can only be built for dimension > 2
584 unsigned int min_dim;
585 if (type.family == NEDELEC_ONE || type.family == RAVIART_THOMAS ||
586 type.family == L2_RAVIART_THOMAS)
587 min_dim = 2;
588 else
589 min_dim = 0;
590
591 // Build an FE object for this type for each dimension from the min_dim up to the dimension of the
592 // current mesh
593 for (unsigned int dim = min_dim; dim <= _mesh_dimension; dim++)
594 {
595 if (!_vector_fe_face_neighbor[dim][type])
596 {
598 FEGenericBase<VectorValue<Real>>::build(dim, type).release();
599 _vector_fe_face_neighbor[dim][type]->add_p_level_in_reinit(type.p_refinement);
600 }
601
602 _vector_fe_face_neighbor[dim][type]->get_phi();
603 _vector_fe_face_neighbor[dim][type]->get_dphi();
604 if (_need_curl.count(type))
605 _vector_fe_face_neighbor[dim][type]->get_curl_phi();
606 if (_need_face_neighbor_div.count(type))
607 _vector_fe_face_neighbor[dim][type]->get_div_phi();
608 }
609}
std::set< FEType > _need_face_neighbor_div
Definition Assembly.h:2884
std::map< FEType, std::unique_ptr< VectorFEShapeData > > _vector_fe_shape_data_face_neighbor
Definition Assembly.h:2775

Referenced by getVectorFEFaceNeighbor().

◆ buildVectorFE()

void Assembly::buildVectorFE ( FEType  type) const
private

Build Vector FEs with a type.

Parameters
typeThe type of FE

Definition at line 478 of file Assembly.C.

479{
480 if (!_vector_fe_shape_data[type])
481 _vector_fe_shape_data[type] = std::make_unique<VectorFEShapeData>();
482
483 // Note that NEDELEC_ONE and RAVIART_THOMAS elements can only be built for dimension > 2
484 unsigned int min_dim;
485 if (type.family == NEDELEC_ONE || type.family == RAVIART_THOMAS ||
486 type.family == L2_RAVIART_THOMAS)
487 min_dim = 2;
488 else
489 min_dim = 0;
490
491 // Build an FE object for this type for each dimension from the min_dim up to the dimension of the
492 // current mesh
493 for (unsigned int dim = min_dim; dim <= _mesh_dimension; dim++)
494 {
495 if (!_vector_fe[dim][type])
496 {
497 _vector_fe[dim][type] = FEGenericBase<VectorValue<Real>>::build(dim, type).release();
498 _vector_fe[dim][type]->add_p_level_in_reinit(type.p_refinement);
499 }
500
501 _vector_fe[dim][type]->get_phi();
502 _vector_fe[dim][type]->get_dphi();
503 if (_need_curl.count(type))
504 _vector_fe[dim][type]->get_curl_phi();
505 if (_need_div.count(type))
506 _vector_fe[dim][type]->get_div_phi();
507 _vector_fe[dim][type]->get_xyz();
508 }
509}
std::map< FEType, std::unique_ptr< VectorFEShapeData > > _vector_fe_shape_data
Shape function values, gradients, second derivatives for each vector FE type.
Definition Assembly.h:2772
std::set< FEType > _need_div
Definition Assembly.h:2881

Referenced by getVectorFE().

◆ buildVectorLowerDFE()

void Assembly::buildVectorLowerDFE ( FEType  type) const
private

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

Parameters
typeThe type of FE

Definition at line 422 of file Assembly.C.

423{
425 _vector_fe_shape_data_lower[type] = std::make_unique<VectorFEShapeData>();
426
427 // Build an FE object for this type for each dimension up to the dimension of
428 // the current mesh minus one (because this is for lower-dimensional
429 // elements!)
430 unsigned int dim = ((type.family == LAGRANGE_VEC) || (type.family == MONOMIAL_VEC)) ? 0 : 2;
431 const auto ending_dim = cast_int<unsigned int>(_mesh_dimension - 1);
432 if (ending_dim < dim)
433 return;
434 for (; dim <= ending_dim; dim++)
435 {
436 if (!_vector_fe_lower[dim][type])
437 {
438 _vector_fe_lower[dim][type] = FEVectorBase::build(dim, type).release();
439 _vector_fe_lower[dim][type]->add_p_level_in_reinit(type.p_refinement);
440 }
441
442 _vector_fe_lower[dim][type]->get_phi();
443 _vector_fe_lower[dim][type]->get_dphi();
444 if (_need_second_derivative.count(type))
445 _vector_fe_lower[dim][type]->get_d2phi();
446 }
447}
std::map< FEType, std::unique_ptr< VectorFEShapeData > > _vector_fe_shape_data_lower
Definition Assembly.h:2776

◆ buildVectorNeighborFE()

void Assembly::buildVectorNeighborFE ( FEType  type) const
private

Build Vector FEs for a neighbor with a type.

Parameters
typeThe type of FE

Definition at line 545 of file Assembly.C.

546{
548 _vector_fe_shape_data_neighbor[type] = std::make_unique<VectorFEShapeData>();
549
550 // Note that NEDELEC_ONE and RAVIART_THOMAS elements can only be built for dimension > 2
551 unsigned int min_dim;
552 if (type.family == NEDELEC_ONE || type.family == RAVIART_THOMAS ||
553 type.family == L2_RAVIART_THOMAS)
554 min_dim = 2;
555 else
556 min_dim = 0;
557
558 // Build an FE object for this type for each dimension from the min_dim up to the dimension of the
559 // current mesh
560 for (unsigned int dim = min_dim; dim <= _mesh_dimension; dim++)
561 {
562 if (!_vector_fe_neighbor[dim][type])
563 {
564 _vector_fe_neighbor[dim][type] = FEGenericBase<VectorValue<Real>>::build(dim, type).release();
565 _vector_fe_neighbor[dim][type]->add_p_level_in_reinit(type.p_refinement);
566 }
567
568 _vector_fe_neighbor[dim][type]->get_phi();
569 _vector_fe_neighbor[dim][type]->get_dphi();
570 if (_need_curl.count(type))
571 _vector_fe_neighbor[dim][type]->get_curl_phi();
572 if (_need_neighbor_div.count(type))
573 _vector_fe_neighbor[dim][type]->get_div_phi();
574 }
575}
std::map< FEType, std::unique_ptr< VectorFEShapeData > > _vector_fe_shape_data_neighbor
Definition Assembly.h:2774
std::set< FEType > _need_neighbor_div
Definition Assembly.h:2883

Referenced by getVectorFENeighbor().

◆ bumpAllQRuleOrder()

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

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

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

Definition at line 635 of file Assembly.C.

636{
637 auto & qdefault = _qrules[Moose::ANY_BLOCK_ID];
638 mooseAssert(qdefault.size() > 0, "default quadrature must be initialized before order bumps");
639
640 unsigned int ndims = _mesh_dimension + 1; // must account for 0-dimensional quadrature.
641 auto & qvec = _qrules[block];
642 if (qvec.size() != ndims || !qvec[0].vol)
643 createQRules(qdefault[0].vol->type(), order, order, order, block);
644 else if (qvec[0].vol->get_order() < order || qvec[0].face->get_order() < order)
645 createQRules(qvec[0].vol->type(),
646 std::max(order, qvec[0].arbitrary_vol->get_order()),
647 std::max(order, qvec[0].vol->get_order()),
648 std::max(order, qvec[0].face->get_order()),
649 block);
650 // otherwise do nothing - quadrature order is already as high as requested
651}
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 ...
Definition Assembly.C:654
std::unordered_map< SubdomainID, std::vector< QRules > > _qrules
Holds quadrature rules for each dimension.
Definition Assembly.h:2458
const SubdomainID ANY_BLOCK_ID
Definition MooseTypes.C:19

◆ bumpVolumeQRuleOrder()

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

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

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

Definition at line 612 of file Assembly.C.

613{
614 auto & qdefault = _qrules[Moose::ANY_BLOCK_ID];
615 mooseAssert(qdefault.size() > 0, "default quadrature must be initialized before order bumps");
616
617 unsigned int ndims = _mesh_dimension + 1; // must account for 0-dimensional quadrature.
618 auto & qvec = _qrules[block];
619 if (qvec.size() != ndims || !qvec[0].vol)
620 createQRules(qdefault[0].vol->type(),
621 qdefault[0].arbitrary_vol->get_order(),
622 volume_order,
623 qdefault[0].face->get_order(),
624 block);
625 else if (qvec[0].vol->get_order() < volume_order)
626 createQRules(qvec[0].vol->type(),
627 qvec[0].arbitrary_vol->get_order(),
628 volume_order,
629 qvec[0].face->get_order(),
630 block);
631 // otherwise do nothing - quadrature order is already as high as requested
632}

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

3150{
3151 if (!computingJacobian() || matrix_tags.empty())
3152 return;
3153
3154 // A single row needs no constraining unless its dof or one of its column dofs is constrained, in
3155 // which case its entries must be distributed to the constraining rows and columns
3156 const auto & single_row_dofs = residuals[0].derivatives().nude_indices();
3157 if (residuals.size() == 1 && !_dof_map.is_constrained_dof(input_row_indices[0]) &&
3158 std::none_of(single_row_dofs.begin(),
3159 single_row_dofs.end(),
3160 [this](const auto dof) { return _dof_map.is_constrained_dof(dof); }))
3161 {
3162 // No constraining is required. (This is likely a finite volume computation if we only have a
3163 // single dof)
3165 residuals, input_row_indices, scaling_factor, LocalDataKey{}, matrix_tags);
3166 return;
3167 }
3168
3169 const auto & compare_dofs = residuals[0].derivatives().nude_indices();
3170#ifndef NDEBUG
3171 auto compare_dofs_set = std::set<dof_id_type>(compare_dofs.begin(), compare_dofs.end());
3172
3173 for (const auto i : make_range(decltype(residuals.size())(1), residuals.size()))
3174 {
3175 const auto & residual = residuals[i];
3176 auto current_dofs_set = std::set<dof_id_type>(residual.derivatives().nude_indices().begin(),
3177 residual.derivatives().nude_indices().end());
3178 mooseAssert(compare_dofs_set == current_dofs_set,
3179 "We're going to see whether the dof sets are the same. IIRC the degree of freedom "
3180 "dependence (as indicated by the dof index set held by the ADReal) has to be the "
3181 "same for every residual passed to this method otherwise constrain_element_matrix "
3182 "will not work.");
3183 }
3184#endif
3185 _column_indices.assign(compare_dofs.begin(), compare_dofs.end());
3186
3187 // If there's no derivatives then there is nothing to do. Moreover, if we pass zero size column
3188 // indices to constrain_element_matrix then we will potentially get errors out of BLAS
3189 if (!_column_indices.size())
3190 return;
3191
3192 // Need to make a copy because we might modify this in constrain_element_matrix
3193 _row_indices.assign(input_row_indices.begin(), input_row_indices.end());
3194
3196 for (const auto i : index_range(_row_indices))
3197 {
3198 const auto & sparse_derivatives = residuals[i].derivatives();
3199
3200 for (const auto j : index_range(_column_indices))
3201 _element_matrix(i, j) = sparse_derivatives[_column_indices[j]] * scaling_factor;
3202 }
3203
3205
3206 for (const auto i : index_range(_row_indices))
3207 for (const auto j : index_range(_column_indices))
3208 cacheJacobian(_row_indices[i], _column_indices[j], _element_matrix(i, j), {}, matrix_tags);
3209}
for(PetscInt i=0;i< nvars;++i)
DenseMatrix< Number > _element_matrix
A working matrix to avoid repeated heap allocations when caching Jacobians that must have libMesh-lev...
Definition Assembly.h:2903
std::vector< dof_id_type > _column_indices
Definition Assembly.h:2908
bool computingJacobian() const
Definition Assembly.h:1954
void cacheJacobian(GlobalDataKey)
Takes the values that are currently in _sub_Kee and appends them to the cached values.
Definition Assembly.C:4111
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.
Definition Assembly.h:3213
std::vector< dof_id_type > _row_indices
Working vectors to avoid repeated heap allocations when caching residuals/Jacobians that must have li...
Definition Assembly.h:2908
void resize(const unsigned int new_m, const unsigned int new_n)
bool is_constrained_dof(const dof_id_type dof) const
auto index_range(const T &sizable)
IntRange< T > make_range(T beg, T end)

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

4112{
4113 for (const auto & it : _cm_ff_entry)
4114 cacheJacobianCoupledVarPair(*it.first, *it.second);
4115
4116 for (const auto & it : _cm_fs_entry)
4117 cacheJacobianCoupledVarPair(*it.first, *it.second);
4118
4119 for (const auto & it : _cm_sf_entry)
4120 cacheJacobianCoupledVarPair(*it.first, *it.second);
4121}
void cacheJacobianCoupledVarPair(const MooseVariableBase &ivar, const MooseVariableBase &jvar)
Caches element matrix for ivar rows and jvar columns.
Definition Assembly.C:4125

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

4535{
4536 for (auto tag : tags)
4537 if (_sys.hasMatrix(tag))
4538 cacheJacobian(i, j, value, LocalDataKey{}, tag);
4539}
Real value(unsigned n, unsigned alpha, unsigned beta, Real x)

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

4523{
4524 _cached_jacobian_rows[tag].push_back(i);
4525 _cached_jacobian_cols[tag].push_back(j);
4526 _cached_jacobian_values[tag].push_back(value);
4527}

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

3678{
3679 if (idof_indices.size() == 0 || jdof_indices.size() == 0)
3680 return;
3681 if (jac_block.n() == 0 || jac_block.m() == 0)
3682 return;
3683 if (!_sys.hasMatrix(tag))
3684 return;
3685
3686 auto & scaling_factors = ivar.arrayScalingFactor();
3687 const unsigned int iv = ivar.number();
3688 const unsigned int jv = jvar.number();
3689
3690 for (unsigned int i = 0; i < ivar.count(); ++i)
3691 {
3692 for (const auto & jt : libMesh::ConstCouplingRow(iv + i, *_cm))
3693 {
3694 if (jt < jv || jt >= jv + jvar.count())
3695 continue;
3696 unsigned int j = jt - jv;
3697
3698 auto di = ivar.componentDofIndices(idof_indices, i);
3699 auto dj = jvar.componentDofIndices(jdof_indices, j);
3700 auto indof = di.size();
3701 auto jndof = dj.size();
3702
3703 unsigned int jj = j;
3704 if (iv == jv && _component_block_diagonal[iv])
3705 // here i must be equal to j
3706 jj = 0;
3707
3708 auto sub = jac_block.sub_matrix(i * indof, indof, jj * jndof, jndof);
3709 if (scaling_factors[i] != 1.0)
3710 sub *= scaling_factors[i];
3711
3712 // If we're computing the jacobian for automatically scaling variables we do not want
3713 // to constrain the element matrix because it introduces 1s on the diagonal for the
3714 // constrained dofs
3716 _dof_map.constrain_element_matrix(sub, di, dj, false);
3717
3718 for (MooseIndex(di) i = 0; i < di.size(); i++)
3719 for (MooseIndex(dj) j = 0; j < dj.size(); j++)
3720 {
3721 _cached_jacobian_values[tag].push_back(sub(i, j));
3722 _cached_jacobian_rows[tag].push_back(di[i]);
3723 _cached_jacobian_cols[tag].push_back(dj[j]);
3724 }
3725 }
3726 }
3727}

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

3793{
3794 const auto has_matrix =
3795 std::any_of(tags.begin(), tags.end(), [this](const auto tag) { return _sys.hasMatrix(tag); });
3796
3797 // Work on a reusable Assembly-owned copy so callers retain their local matrix. This also lets us
3798 // apply constraints and scaling once before caching the same block to every requested matrix tag.
3799 if ((idof_indices.size() > 0) && (jdof_indices.size() > 0) && jac_block.n() && jac_block.m() &&
3800 has_matrix)
3801 {
3802 _row_indices.assign(idof_indices.begin(), idof_indices.end());
3803 _column_indices.assign(jdof_indices.begin(), jdof_indices.end());
3804 _element_matrix = jac_block;
3805
3806 // If we're computing the jacobian for automatically scaling variables we do not want to
3807 // constrain the element matrix because it introduces 1s on the diagonal for the constrained
3808 // dofs
3811
3812 if (scaling_factor != 1.0)
3813 _element_matrix *= scaling_factor;
3814
3815 for (const auto i : index_range(_row_indices))
3816 for (const auto j : index_range(_column_indices))
3818 _row_indices[i], _column_indices[j], _element_matrix(i, j), LocalDataKey{}, tags);
3819 }
3820}

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

3737{
3738 if (idof_indices.size() == 0 || jdof_indices.size() == 0)
3739 return;
3740 if (jac_block.n() == 0 || jac_block.m() == 0)
3741 return;
3742 if (!_sys.hasMatrix(tag))
3743 return;
3744
3745 auto & scaling_factor = ivar.arrayScalingFactor();
3746
3747 for (unsigned int i = 0; i < ivar.count(); ++i)
3748 {
3749 unsigned int iv = ivar.number();
3750 for (const auto & jt : libMesh::ConstCouplingRow(iv + i, *_cm))
3751 {
3752 unsigned int jv = jvar.number();
3753 if (jt < jv || jt >= jv + jvar.count())
3754 continue;
3755 unsigned int j = jt - jv;
3756
3757 auto di = ivar.componentDofIndices(idof_indices, i);
3758 auto dj = jvar.componentDofIndices(jdof_indices, j);
3759 auto indof = di.size();
3760 auto jndof = dj.size();
3761
3762 unsigned int jj = j;
3763 if (iv == jv && _component_block_diagonal[iv])
3764 // here i must be equal to j
3765 jj = 0;
3766
3767 auto sub = jac_block.sub_matrix(i * indof, indof, jj * jndof, jndof);
3768 if (scaling_factor[i] != 1.0)
3769 sub *= scaling_factor[i];
3770
3771 _dof_map.constrain_element_matrix(sub, di, dj, false);
3772
3773 for (MooseIndex(di) i = 0; i < di.size(); i++)
3774 for (MooseIndex(dj) j = 0; j < dj.size(); j++)
3775 if (sub(i, j) != 0.0) // no storage allocated for unimplemented jacobian terms,
3776 // maintaining maximum sparsity possible
3777 {
3778 _cached_jacobian_values[tag].push_back(sub(i, j));
3779 _cached_jacobian_rows[tag].push_back(di[i]);
3780 _cached_jacobian_cols[tag].push_back(dj[j]);
3781 }
3782 }
3783 }
3784}

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

4127{
4128 auto i = ivar.number();
4129 auto j = jvar.number();
4130 for (MooseIndex(_jacobian_block_used) tag = 0; tag < _jacobian_block_used.size(); tag++)
4131 if (jacobianBlockUsed(tag, i, j) && _sys.hasMatrix(tag))
4132 cacheJacobianBlock(jacobianBlock(i, j, LocalDataKey{}, tag),
4133 ivar,
4134 jvar,
4135 ivar.dofIndices(),
4136 jvar.dofIndices(),
4137 tag);
4138}
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 eve...
Definition Assembly.C:3787

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

4202{
4203 for (const auto & it : _cm_ff_entry)
4204 {
4205 auto ivar = it.first;
4206 auto jvar = it.second;
4207 auto i = ivar->number();
4208 auto j = jvar->number();
4209 for (MooseIndex(_jacobian_block_lower_used) tag = 0; tag < _jacobian_block_lower_used.size();
4210 tag++)
4211 if (jacobianBlockLowerUsed(tag, i, j) && _sys.hasMatrix(tag))
4212 {
4213 cacheJacobianBlock(jacobianBlockMortar(Moose::LowerLower, i, j, LocalDataKey{}, tag),
4214 *ivar,
4215 *jvar,
4216 ivar->dofIndicesLower(),
4217 jvar->dofIndicesLower(),
4218 tag);
4219
4221 *ivar,
4222 *jvar,
4223 ivar->dofIndicesLower(),
4224 jvar->dofIndices(),
4225 tag);
4226
4228 *ivar,
4229 *jvar,
4230 ivar->dofIndicesLower(),
4231 jvar->dofIndicesNeighbor(),
4232 tag);
4233
4235 *ivar,
4236 *jvar,
4237 ivar->dofIndices(),
4238 jvar->dofIndicesLower(),
4239 tag);
4240
4242 jacobianBlockMortar(Moose::SecondarySecondary, i, j, LocalDataKey{}, tag),
4243 *ivar,
4244 *jvar,
4245 ivar->dofIndices(),
4246 jvar->dofIndices(),
4247 tag);
4248
4250 *ivar,
4251 *jvar,
4252 ivar->dofIndices(),
4253 jvar->dofIndicesNeighbor(),
4254 tag);
4255
4257 *ivar,
4258 *jvar,
4259 ivar->dofIndicesNeighbor(),
4260 jvar->dofIndicesLower(),
4261 tag);
4262
4264 *ivar,
4265 *jvar,
4266 ivar->dofIndicesNeighbor(),
4267 jvar->dofIndices(),
4268 tag);
4269
4271 *ivar,
4272 *jvar,
4273 ivar->dofIndicesNeighbor(),
4274 jvar->dofIndicesNeighbor(),
4275 tag);
4276 }
4277 }
4278}
@ SecondarySecondary
Definition MooseTypes.h:856
@ SecondaryPrimary
Definition MooseTypes.h:857
@ PrimarySecondary
Definition MooseTypes.h:858
@ PrimaryPrimary
Definition MooseTypes.h:859

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

4164{
4165 for (const auto & it : _cm_ff_entry)
4166 {
4167 auto ivar = it.first;
4168 auto jvar = it.second;
4169 auto i = ivar->number();
4170 auto j = jvar->number();
4171
4172 for (MooseIndex(_jacobian_block_neighbor_used) tag = 0;
4173 tag < _jacobian_block_neighbor_used.size();
4174 tag++)
4175 if (jacobianBlockNeighborUsed(tag, i, j) && _sys.hasMatrix(tag))
4176 {
4178 *ivar,
4179 *jvar,
4180 ivar->dofIndices(),
4181 jvar->dofIndicesNeighbor(),
4182 tag);
4184 *ivar,
4185 *jvar,
4186 ivar->dofIndicesNeighbor(),
4187 jvar->dofIndices(),
4188 tag);
4190 jacobianBlockNeighbor(Moose::NeighborNeighbor, i, j, LocalDataKey{}, tag),
4191 *ivar,
4192 *jvar,
4193 ivar->dofIndicesNeighbor(),
4194 jvar->dofIndicesNeighbor(),
4195 tag);
4196 }
4197 }
4198}

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

4142{
4143 for (const auto & it : _cm_nonlocal_entry)
4144 {
4145 auto ivar = it.first;
4146 auto jvar = it.second;
4147 auto i = ivar->number();
4148 auto j = jvar->number();
4149 for (MooseIndex(_jacobian_block_nonlocal_used) tag = 0;
4150 tag < _jacobian_block_nonlocal_used.size();
4151 tag++)
4152 if (jacobianBlockNonlocalUsed(tag, i, j) && _sys.hasMatrix(tag))
4153 cacheJacobianBlockNonzero(jacobianBlockNonlocal(i, j, LocalDataKey{}, tag),
4154 *ivar,
4155 *jvar,
4156 ivar->dofIndices(),
4157 jvar->allDofIndices(),
4158 tag);
4159 }
4160}
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.
Definition Assembly.C:3731

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

3218{
3219 mooseAssert(residuals.size() == row_indices.size(),
3220 "The number of residuals should match the number of dof indices");
3221 mooseAssert(residuals.size() >= 1, "Why you calling me with no residuals?");
3222
3223 if (!computingJacobian() || matrix_tags.empty())
3224 return;
3225
3226 for (const auto i : index_range(row_indices))
3227 {
3228 const auto row_index = row_indices[i];
3229
3230 const auto & sparse_derivatives = residuals[i].derivatives();
3231 const auto & column_indices = sparse_derivatives.nude_indices();
3232 const auto & raw_derivatives = sparse_derivatives.nude_data();
3233
3234 for (std::size_t j = 0; j < column_indices.size(); ++j)
3236 row_index, column_indices[j], raw_derivatives[j] * scaling_factor, {}, matrix_tags);
3237 }
3238}

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
dofThe degree of freedom to add the residual contribution to
valueThe value of the residual contribution.
tagsthe contribution should go to all these tags

Definition at line 3483 of file Assembly.C.

3484{
3485 for (auto & tag : tags)
3486 cacheResidual(dof, value, tag);
3487}
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 ...
Definition Assembly.C:3458

◆ 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
dofThe degree of freedom to add the residual contribution to
valueThe value of the residual contribution.
TagIDthe contribution should go to this tagged residual

Definition at line 3473 of file Assembly.C.

3474{
3475 const VectorTag & tag = _subproblem.getVectorTag(tag_id);
3476
3477 _cached_residual_values[tag._type_id].push_back(value);
3478 _cached_residual_rows[tag._type_id].push_back(dof);
3479}
virtual const VectorTag & getVectorTag(const TagID tag_id) const
Get a VectorTag from a TagID.
Definition SubProblem.C:153
Storage for all of the information pretaining to a vector tag.
Definition VectorTag.h:18

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

3459{
3460 const std::vector<MooseVariableFEBase *> & vars = _sys.getVariables(_tid);
3461 for (const auto & var : vars)
3462 for (const auto & vector_tag : tags)
3463 if (_sys.hasVector(vector_tag._id))
3464 cacheResidualBlock(_cached_residual_values[vector_tag._type_id],
3465 _cached_residual_rows[vector_tag._type_id],
3466 _sub_Re[vector_tag._type_id][var->number()],
3467 var->dofIndices(),
3468 var->arrayScalingFactor());
3469}
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.
Definition Assembly.C:3332

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

3337{
3338 if (dof_indices.size() > 0 && res_block.size())
3339 {
3340 _temp_dof_indices = dof_indices;
3341 _tmp_Re = res_block;
3343
3344 for (MooseIndex(_tmp_Re) i = 0; i < _tmp_Re.size(); i++)
3345 {
3346 cached_residual_values.push_back(_tmp_Re(i));
3347 cached_residual_rows.push_back(_temp_dof_indices[i]);
3348 }
3349 }
3350
3351 res_block.zero();
3352}
virtual void zero() override final

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

3523{
3524 const std::vector<MooseVariableFEBase *> & vars = _sys.getVariables(_tid);
3525 for (const auto & var : vars)
3526 for (const auto & vector_tag : tags)
3527 if (_sys.hasVector(vector_tag._id))
3528 cacheResidualBlock(_cached_residual_values[vector_tag._type_id],
3529 _cached_residual_rows[vector_tag._type_id],
3530 _sub_Rl[vector_tag._type_id][var->number()],
3531 var->dofIndicesLower(),
3532 var->arrayScalingFactor());
3533}

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

3509{
3510 const std::vector<MooseVariableFEBase *> & vars = _sys.getVariables(_tid);
3511 for (const auto & var : vars)
3512 for (const auto & vector_tag : tags)
3513 if (_sys.hasVector(vector_tag._id))
3514 cacheResidualBlock(_cached_residual_values[vector_tag._type_id],
3515 _cached_residual_rows[vector_tag._type_id],
3516 _sub_Rn[vector_tag._type_id][var->number()],
3517 var->dofIndicesNeighbor(),
3518 var->arrayScalingFactor());
3519}

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

3494{
3495 // Add the residual value and dof_index to cached_residual_values and cached_residual_rows
3496 // respectively.
3497 // This is used by NodalConstraint.C to cache the residual calculated for primary and secondary
3498 // node.
3499 const VectorTag & vector_tag = _subproblem.getVectorTag(tag);
3500 for (MooseIndex(dof_index) i = 0; i < dof_index.size(); ++i)
3501 {
3502 _cached_residual_values[vector_tag._type_id].push_back(res(i));
3503 _cached_residual_rows[vector_tag._type_id].push_back(dof_index[i]);
3504 }
3505}

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

3089{
3090 mooseAssert(residuals.size() == input_row_indices.size(),
3091 "The number of residuals should match the number of dof indices");
3092 mooseAssert(residuals.size() >= 1, "Why you calling me with no residuals?");
3093
3094 if (!computingResidual() || vector_tags.empty())
3095 return;
3096
3097 // A single row needs no constraining unless its dof is constrained (e.g. by a periodic boundary,
3098 // a hanging node, or a user constraint), in which case its residual must be distributed to the
3099 // constraining dofs
3100 if (residuals.size() == 1 && !_dof_map.is_constrained_dof(input_row_indices[0]))
3101 {
3102 // No constraining is required. (This is likely a finite volume computation if we only have a
3103 // single dof)
3105 residuals, input_row_indices, scaling_factor, LocalDataKey{}, vector_tags);
3106 return;
3107 }
3108
3109 // Need to make a copy because we might modify this in constrain_element_vector
3110 _row_indices.assign(input_row_indices.begin(), input_row_indices.end());
3111
3113 for (const auto i : index_range(_row_indices))
3114 _element_vector(i) = MetaPhysicL::raw_value(residuals[i]) * scaling_factor;
3115
3116 // At time of writing, this method doesn't do anything with the asymmetric_constraint_rows
3117 // argument, but we set it to false to be consistent with processLocalResidual
3119 _element_vector, _row_indices, /*asymmetric_constraint_rows=*/false);
3120
3121 for (const auto i : index_range(_row_indices))
3122 cacheResidual(_row_indices[i], _element_vector(i), vector_tags);
3123}
void cacheResidualsWithoutConstraints(const Residuals &residuals, const Indices &row_indices, Real scaling_factor, LocalDataKey, const std::set< TagID > &vector_tags)
Process the supplied residual values.
Definition Assembly.h:3127
bool computingResidual() const
Definition Assembly.h:1949
DenseVector< Number > _element_vector
A working vector to avoid repeated heap allocations when caching residuals that must have libMesh-lev...
Definition Assembly.h:2898
void resize(const unsigned int n)
void constrain_element_vector(DenseVector< Number > &rhs, std::vector< dof_id_type > &dofs, bool asymmetric_constraint_rows=true) const
We need to instantiate the following CompareTypes to tell the compiler that ADReal is a subtype of Ch...
auto raw_value(const Eigen::Map< T > &in)

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

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

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

4573{
4574 for (MooseIndex(_cached_jacobian_rows) tag = 0; tag < _cached_jacobian_rows.size(); tag++)
4575 {
4576 _cached_jacobian_rows[tag].clear();
4577 _cached_jacobian_cols[tag].clear();
4578 _cached_jacobian_values[tag].clear();
4579 }
4580}

Referenced by setCachedJacobian(), and zeroCachedJacobian().

◆ clearCachedQRules()

void Assembly::clearCachedQRules ( )

Set the cached quadrature rules to nullptr.

Definition at line 763 of file Assembly.C.

764{
765 _current_qrule = nullptr;
766 _current_qrule_face = nullptr;
767 _current_qrule_lower = nullptr;
768 _current_qrule_neighbor = nullptr;
769}

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

3560{
3561 auto & values = _cached_residual_values[vector_tag._type_id];
3562 auto & rows = _cached_residual_rows[vector_tag._type_id];
3563
3564 mooseAssert(values.size() == rows.size(),
3565 "Number of cached residuals and number of rows must match!");
3566
3567 // Keep track of the largest size so we can use it to reserve and avoid
3568 // as much dynamic allocation as possible
3569 if (_max_cached_residuals < values.size())
3571
3572 // Clear both vectors (keeps the capacity the same)
3573 values.clear();
3574 rows.clear();
3575 // And then reserve: use 2 as a fudge factor to *really* avoid dynamic allocation!
3576 values.reserve(_max_cached_residuals * 2);
3577 rows.reserve(_max_cached_residuals * 2);
3578}

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

3552{
3553 for (const auto & vector_tag : _residual_vector_tags)
3554 clearCachedResiduals(vector_tag);
3555}

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

2166{
2167 const auto dim = elem.dim();
2168
2170 {
2171 auto n_qp = _current_qrule_face->n_points();
2172 resizeADMappingObjects(n_qp, dim);
2173 _ad_normals.resize(n_qp);
2174 _ad_JxW_face.resize(n_qp);
2178 _ad_curvatures.resize(n_qp);
2179
2180 if (_displaced)
2181 {
2182 const auto & qw = _current_qrule_face->get_weights();
2183 // computeFaceMap supplies the AD face JxW, normals and points; the single-point map only adds
2184 // the inverse map that computeGradPhiAD needs
2186 computeFaceMap(elem, side, qw);
2188 {
2189 // Faces can have different numbers of quadrature points, so grow the weights as needed
2190 static thread_local std::vector<Real> dummy_qw;
2191 dummy_qw.resize(n_qp, 1.);
2192
2193 for (unsigned int qp = 0; qp != n_qp; qp++)
2195 }
2196 }
2197 else
2198 {
2199 for (unsigned qp = 0; qp < n_qp; ++qp)
2200 {
2202 _ad_normals[qp] = _current_normals[qp];
2203 }
2205 for (unsigned qp = 0; qp < n_qp; ++qp)
2208 for (unsigned qp = 0; qp < n_qp; ++qp)
2209 _ad_curvatures[qp] = _curvatures[qp];
2210 }
2211
2213 {
2214 for (const auto & it : _fe_face[dim])
2215 {
2216 FEBase & fe = *it.second;
2217 auto fe_type = it.first;
2218 auto num_shapes = FEInterface::n_shape_functions(fe_type, &elem);
2219 auto & grad_phi = _ad_grad_phi_data_face[fe_type];
2220
2221 grad_phi.resize(num_shapes);
2222 for (decltype(num_shapes) i = 0; i < num_shapes; ++i)
2223 grad_phi[i].resize(n_qp);
2224
2225 const auto & regular_grad_phi = _fe_shape_data_face[fe_type]->_grad_phi;
2226
2227 if (_displaced)
2228 computeGradPhiAD(&elem, n_qp, grad_phi, &fe);
2229 else
2230 for (decltype(num_shapes) i = 0; i < num_shapes; ++i)
2231 for (unsigned qp = 0; qp < n_qp; ++qp)
2232 grad_phi[i][qp] = regular_grad_phi[i][qp];
2233 }
2234 for (const auto & it : _vector_fe_face[dim])
2235 {
2236 FEVectorBase & fe = *it.second;
2237 auto fe_type = it.first;
2238 auto num_shapes = FEInterface::n_shape_functions(fe_type, &elem);
2239 auto & grad_phi = _ad_vector_grad_phi_data_face[fe_type];
2240
2241 grad_phi.resize(num_shapes);
2242 for (decltype(num_shapes) i = 0; i < num_shapes; ++i)
2243 grad_phi[i].resize(n_qp);
2244
2245 const auto & regular_grad_phi = _vector_fe_shape_data_face[fe_type]->_grad_phi;
2246
2247 if (_displaced)
2248 computeGradPhiAD(&elem, n_qp, grad_phi, &fe);
2249 else
2250 for (decltype(num_shapes) i = 0; i < num_shapes; ++i)
2251 for (unsigned qp = 0; qp < n_qp; ++qp)
2252 grad_phi[i][qp] = regular_grad_phi[i][qp];
2253 }
2254 }
2255 }
2256}
bool _need_ad_grad_phi_face
Whether any object needs the AD face shape function gradients.
Definition Assembly.h:2787
MooseArray< Real > _current_JxW_face
The current transformed jacobian weights on a face.
Definition Assembly.h:2527
const Elem *const & elem() const
Return the current element.
Definition Assembly.h:410
MooseArray< Point > _current_q_points_face
The current quadrature points on a face.
Definition Assembly.h:2525
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 v...
const unsigned int & side() const
Returns the current side.
Definition Assembly.h:442
void resizeADMappingObjects(unsigned int n_qp, unsigned int dim)
resize any objects that contribute to automatic differentiation-related mapping calculations
Definition Assembly.C:1014
MooseArray< Point > _current_normals
The current Normal vectors at the quadrature points.
Definition Assembly.h:2529
void computeFaceMap(const Elem &elem, const unsigned int side, const std::vector< Real > &qw)
Definition Assembly.C:1393
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 dependen...
Definition Assembly.C:1044
void resize(unsigned int size)
Change the number of elements the array can store.
Definition MooseArray.h:216
virtual void haveADObjects(bool have_ad_objects)
Method for setting whether we have any ad objects.
Definition SubProblem.h:778
unsigned int n_points() const
const std::vector< Real > & get_weights() const
FEGenericBase< RealGradient > FEVectorBase
FEGenericBase< Real > FEBase

Referenced by reinitElemFaceRef(), and reinitFEFace().

◆ computeCurrentElemVolume()

void Assembly::computeCurrentElemVolume ( )
private

Definition at line 1799 of file Assembly.C.

1800{
1802 return;
1803
1809
1811 for (unsigned int qp = 0; qp < _current_qrule->n_points(); qp++)
1813
1815}
MooseArray< Point > _current_q_points
The current list of quadrature points.
Definition Assembly.h:2417
void setCoordinateTransformation(const libMesh::QBase *qrule, const Points &q_points, Coords &coord, SubdomainID sub_id)
MooseArray< Real > _current_JxW
The current list of transformed jacobian weights.
Definition Assembly.h:2419

Referenced by reinit(), and reinit().

◆ computeCurrentFaceVolume()

void Assembly::computeCurrentFaceVolume ( )
private

Definition at line 1818 of file Assembly.C.

1819{
1821 return;
1822
1828
1830 for (unsigned int qp = 0; qp < _current_qrule_face->n_points(); qp++)
1832
1834}

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

◆ computeCurrentNeighborVolume()

void Assembly::computeCurrentNeighborVolume ( )
private

◆ computeFaceMap()

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

Definition at line 1393 of file Assembly.C.

1394{
1395 // Important quantities calculated by this method:
1396 // - _ad_JxW_face
1397 // - _ad_q_points_face
1398 // - _ad_normals
1399 // - _ad_curvatures
1400
1401 const Elem & side_elem = _compute_face_map_side_elem_builder(elem, side);
1402 const auto dim = elem.dim();
1403 const auto n_qp = qw.size();
1404 const auto & dpsidxi_map = _holder_fe_face_helper[dim]->get_fe_map().get_dpsidxi();
1405 const auto & dpsideta_map = _holder_fe_face_helper[dim]->get_fe_map().get_dpsideta();
1406 const auto & psi_map = _holder_fe_face_helper[dim]->get_fe_map().get_psi();
1407 std::vector<std::vector<Real>> const * d2psidxi2_map = nullptr;
1408 std::vector<std::vector<Real>> const * d2psidxideta_map = nullptr;
1409 std::vector<std::vector<Real>> const * d2psideta2_map = nullptr;
1410 const auto sys_num = _sys.number();
1411 const bool do_derivatives = ADReal::do_derivatives && sys_num == _subproblem.currentNlSysNum();
1412
1414 {
1415 d2psidxi2_map = &_holder_fe_face_helper[dim]->get_fe_map().get_d2psidxi2();
1416 d2psidxideta_map = &_holder_fe_face_helper[dim]->get_fe_map().get_d2psidxideta();
1417 d2psideta2_map = &_holder_fe_face_helper[dim]->get_fe_map().get_d2psideta2();
1418 }
1419
1420 switch (dim)
1421 {
1422 case 1:
1423 {
1424 if (!n_qp)
1425 break;
1426
1427 if (side_elem.node_id(0) == elem.node_id(0))
1428 _ad_normals[0] = Point(-1.);
1429 else
1430 _ad_normals[0] = Point(1.);
1431
1432 VectorValue<ADReal> side_point;
1434 {
1435 const Node & node = side_elem.node_ref(0);
1436 side_point = node;
1437
1438 if (do_derivatives)
1439 for (const auto & [disp_num, direction] : _disp_numbers_and_directions)
1441 side_point(direction).derivatives(), node.dof_number(sys_num, disp_num, 0), 1.);
1442 }
1443
1444 for (const auto p : make_range(n_qp))
1445 {
1447 {
1448 _ad_q_points_face[p].zero();
1449 _ad_q_points_face[p].add_scaled(side_point, psi_map[0][p]);
1450 }
1451
1452 _ad_normals[p] = _ad_normals[0];
1453 _ad_JxW_face[p] = 1.0 * qw[p];
1454 }
1455
1456 break;
1457 }
1458
1459 case 2:
1460 {
1461 _ad_dxyzdxi_map.resize(n_qp);
1463 _ad_d2xyzdxi2_map.resize(n_qp);
1464
1465 for (const auto p : make_range(n_qp))
1466 _ad_dxyzdxi_map[p].zero();
1468 for (const auto p : make_range(n_qp))
1471 for (const auto p : make_range(n_qp))
1473
1474 const auto n_mapping_shape_functions =
1475 libMesh::FE<2, LAGRANGE>::n_dofs(&side_elem, side_elem.default_order());
1476
1477 for (unsigned int i = 0; i < n_mapping_shape_functions; i++)
1478 {
1479 const Node & node = side_elem.node_ref(i);
1480 VectorValue<ADReal> side_point = node;
1481
1482 if (do_derivatives)
1483 for (const auto & [disp_num, direction] : _disp_numbers_and_directions)
1485 side_point(direction).derivatives(), node.dof_number(sys_num, disp_num, 0), 1.);
1486
1487 for (const auto p : make_range(n_qp))
1488 _ad_dxyzdxi_map[p].add_scaled(side_point, dpsidxi_map[i][p]);
1490 for (const auto p : make_range(n_qp))
1491 _ad_q_points_face[p].add_scaled(side_point, psi_map[i][p]);
1493 for (const auto p : make_range(n_qp))
1494 _ad_d2xyzdxi2_map[p].add_scaled(side_point, (*d2psidxi2_map)[i][p]);
1495 }
1496
1497 for (const auto p : make_range(n_qp))
1498 {
1499 _ad_normals[p] =
1500 (VectorValue<ADReal>(_ad_dxyzdxi_map[p](1), -_ad_dxyzdxi_map[p](0), 0.)).unit();
1501 const auto the_jac = _ad_dxyzdxi_map[p].norm();
1502 _ad_JxW_face[p] = the_jac * qw[p];
1504 {
1505 const auto numerator = _ad_d2xyzdxi2_map[p] * _ad_normals[p];
1506 const auto denominator = _ad_dxyzdxi_map[p].norm_sq();
1507 libmesh_assert_not_equal_to(denominator, 0);
1508 _ad_curvatures[p] = numerator / denominator;
1509 }
1510 }
1511
1512 break;
1513 }
1514
1515 case 3:
1516 {
1517 _ad_dxyzdxi_map.resize(n_qp);
1518 _ad_dxyzdeta_map.resize(n_qp);
1520 {
1521 _ad_d2xyzdxi2_map.resize(n_qp);
1522 _ad_d2xyzdxideta_map.resize(n_qp);
1523 _ad_d2xyzdeta2_map.resize(n_qp);
1524 }
1525
1526 for (const auto p : make_range(n_qp))
1527 {
1528 _ad_dxyzdxi_map[p].zero();
1529 _ad_dxyzdeta_map[p].zero();
1530 }
1532 for (const auto p : make_range(n_qp))
1535 for (const auto p : make_range(n_qp))
1536 {
1537 _ad_d2xyzdxi2_map[p].zero();
1538 _ad_d2xyzdxideta_map[p].zero();
1539 _ad_d2xyzdeta2_map[p].zero();
1540 }
1541
1542 const unsigned int n_mapping_shape_functions =
1543 libMesh::FE<3, LAGRANGE>::n_dofs(&side_elem, side_elem.default_order());
1544
1545 for (unsigned int i = 0; i < n_mapping_shape_functions; i++)
1546 {
1547 const Node & node = side_elem.node_ref(i);
1548 VectorValue<ADReal> side_point = node;
1549
1550 if (do_derivatives)
1551 for (const auto & [disp_num, direction] : _disp_numbers_and_directions)
1553 side_point(direction).derivatives(), node.dof_number(sys_num, disp_num, 0), 1.);
1554
1555 for (const auto p : make_range(n_qp))
1556 {
1557 _ad_dxyzdxi_map[p].add_scaled(side_point, dpsidxi_map[i][p]);
1558 _ad_dxyzdeta_map[p].add_scaled(side_point, dpsideta_map[i][p]);
1559 }
1561 for (const auto p : make_range(n_qp))
1562 _ad_q_points_face[p].add_scaled(side_point, psi_map[i][p]);
1564 for (const auto p : make_range(n_qp))
1565 {
1566 _ad_d2xyzdxi2_map[p].add_scaled(side_point, (*d2psidxi2_map)[i][p]);
1567 _ad_d2xyzdxideta_map[p].add_scaled(side_point, (*d2psidxideta_map)[i][p]);
1568 _ad_d2xyzdeta2_map[p].add_scaled(side_point, (*d2psideta2_map)[i][p]);
1569 }
1570 }
1571
1572 for (const auto p : make_range(n_qp))
1573 {
1574 _ad_normals[p] = _ad_dxyzdxi_map[p].cross(_ad_dxyzdeta_map[p]).unit();
1575
1576 const auto &dxdxi = _ad_dxyzdxi_map[p](0), &dxdeta = _ad_dxyzdeta_map[p](0),
1577 &dydxi = _ad_dxyzdxi_map[p](1), &dydeta = _ad_dxyzdeta_map[p](1),
1578 &dzdxi = _ad_dxyzdxi_map[p](2), &dzdeta = _ad_dxyzdeta_map[p](2);
1579
1580 const auto g11 = (dxdxi * dxdxi + dydxi * dydxi + dzdxi * dzdxi);
1581
1582 const auto g12 = (dxdxi * dxdeta + dydxi * dydeta + dzdxi * dzdeta);
1583
1584 const auto & g21 = g12;
1585
1586 const auto g22 = (dxdeta * dxdeta + dydeta * dydeta + dzdeta * dzdeta);
1587
1588 using std::sqrt;
1589 const auto the_jac = sqrt(g11 * g22 - g12 * g21);
1590
1591 _ad_JxW_face[p] = the_jac * qw[p];
1592
1594 {
1595 const auto L = -_ad_d2xyzdxi2_map[p] * _ad_normals[p];
1596 const auto M = -_ad_d2xyzdxideta_map[p] * _ad_normals[p];
1597 const auto N = -_ad_d2xyzdeta2_map[p] * _ad_normals[p];
1598 const auto E = _ad_dxyzdxi_map[p].norm_sq();
1599 const auto F = _ad_dxyzdxi_map[p] * _ad_dxyzdeta_map[p];
1600 const auto G = _ad_dxyzdeta_map[p].norm_sq();
1601
1602 const auto numerator = E * N - 2. * F * M + G * L;
1603 const auto denominator = E * G - F * F;
1604 libmesh_assert_not_equal_to(denominator, 0.);
1605 _ad_curvatures[p] = 0.5 * numerator / denominator;
1606 }
1607 }
1608
1609 break;
1610 }
1611
1612 default:
1613 mooseError("Invalid dimension dim = ", dim);
1614 }
1615}
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application.
Definition MooseError.h:311
std::vector< VectorValue< ADReal > > _ad_dxyzdxi_map
AD quantities.
Definition Assembly.h:2840
std::vector< VectorValue< ADReal > > _ad_d2xyzdeta2_map
Definition Assembly.h:2845
std::vector< VectorValue< ADReal > > _ad_d2xyzdxideta_map
Definition Assembly.h:2844
std::vector< VectorValue< ADReal > > _ad_dxyzdeta_map
Definition Assembly.h:2841
const Node *const & node() const
Returns the reference to the node.
Definition Assembly.h:541
libMesh::ElemSideBuilder _compute_face_map_side_elem_builder
In place side element builder for computeFaceMap()
Definition Assembly.h:2891
std::vector< VectorValue< ADReal > > _ad_d2xyzdxi2_map
Definition Assembly.h:2843
virtual unsigned int currentNlSysNum() const =0
unsigned int number() const
Gets the number of this system.
unsigned int n_dofs(const ElemType t, const Order o)
CTSub CT_OPERATOR_BINARY CTMul CTCompareLess CTCompareGreater CTCompareEqual _arg template * sqrt(_arg)) *_arg.template D< dtag >()) CT_SIMPLE_UNARY_FUNCTION(tanh
void derivInsert(SemiDynamicSparseNumberArray< Real, libMesh::dof_id_type, NWrapper< N > > &derivs, libMesh::dof_id_type index, Real value)
Definition ADReal.h:21
const Number zero

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

938{
939 // This function relies on the fact that FE::reinit has already been called. FE::reinit will
940 // importantly have already called FEMap::init_shape_functions which will have computed
941 // these quantities at the integration/quadrature points: dphidxi,
942 // dphideta, and dphidzeta (e.g. \nabla phi w.r.t. reference coordinates). These *phi* quantities
943 // are independent of mesh displacements when using a quadrature rule.
944 //
945 // Note that a user could have specified custom integration points (e.g. independent of a
946 // quadrature rule) which could very well depend on displacements. In that case even the *phi*
947 // quantities from the above paragraph would be a function of the displacements and we would be
948 // missing that derivative information in the calculations below
949
950 auto dim = elem->dim();
951 const auto & dphidxi = fe->get_dphidxi();
952 const auto & dphideta = fe->get_dphideta();
953 const auto & dphidzeta = fe->get_dphidzeta();
954 auto num_shapes = grad_phi.size();
955
956 switch (dim)
957 {
958 case 0:
959 {
960 for (decltype(num_shapes) i = 0; i < num_shapes; ++i)
961 for (unsigned qp = 0; qp < n_qp; ++qp)
962 grad_phi[i][qp] = 0;
963 break;
964 }
965
966 case 1:
967 {
968 for (decltype(num_shapes) i = 0; i < num_shapes; ++i)
969 for (unsigned qp = 0; qp < n_qp; ++qp)
970 {
971 grad_phi[i][qp].slice(0) = dphidxi[i][qp] * _ad_dxidx_map[qp];
972 grad_phi[i][qp].slice(1) = dphidxi[i][qp] * _ad_dxidy_map[qp];
973 grad_phi[i][qp].slice(2) = dphidxi[i][qp] * _ad_dxidz_map[qp];
974 }
975 break;
976 }
977
978 case 2:
979 {
980 for (decltype(num_shapes) i = 0; i < num_shapes; ++i)
981 for (unsigned qp = 0; qp < n_qp; ++qp)
982 {
983 grad_phi[i][qp].slice(0) =
984 dphidxi[i][qp] * _ad_dxidx_map[qp] + dphideta[i][qp] * _ad_detadx_map[qp];
985 grad_phi[i][qp].slice(1) =
986 dphidxi[i][qp] * _ad_dxidy_map[qp] + dphideta[i][qp] * _ad_detady_map[qp];
987 grad_phi[i][qp].slice(2) =
988 dphidxi[i][qp] * _ad_dxidz_map[qp] + dphideta[i][qp] * _ad_detadz_map[qp];
989 }
990 break;
991 }
992
993 case 3:
994 {
995 for (decltype(num_shapes) i = 0; i < num_shapes; ++i)
996 for (unsigned qp = 0; qp < n_qp; ++qp)
997 {
998 grad_phi[i][qp].slice(0) = dphidxi[i][qp] * _ad_dxidx_map[qp] +
999 dphideta[i][qp] * _ad_detadx_map[qp] +
1000 dphidzeta[i][qp] * _ad_dzetadx_map[qp];
1001 grad_phi[i][qp].slice(1) = dphidxi[i][qp] * _ad_dxidy_map[qp] +
1002 dphideta[i][qp] * _ad_detady_map[qp] +
1003 dphidzeta[i][qp] * _ad_dzetady_map[qp];
1004 grad_phi[i][qp].slice(2) = dphidxi[i][qp] * _ad_dxidz_map[qp] +
1005 dphideta[i][qp] * _ad_detadz_map[qp] +
1006 dphidzeta[i][qp] * _ad_dzetadz_map[qp];
1007 }
1008 break;
1009 }
1010 }
1011}
std::vector< ADReal > _ad_dzetady_map
Definition Assembly.h:2856
std::vector< ADReal > _ad_detadx_map
Definition Assembly.h:2852
std::vector< ADReal > _ad_dxidx_map
Definition Assembly.h:2849
std::vector< ADReal > _ad_dxidz_map
Definition Assembly.h:2851
std::vector< ADReal > _ad_dzetadx_map
Definition Assembly.h:2855
std::vector< ADReal > _ad_detadz_map
Definition Assembly.h:2854
std::vector< ADReal > _ad_dzetadz_map
Definition Assembly.h:2857
std::vector< ADReal > _ad_detady_map
Definition Assembly.h:2853
std::vector< ADReal > _ad_dxidy_map
Definition Assembly.h:2850

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

1048{
1049 // This function relies on the fact that FE::reinit has already been called. FE::reinit will
1050 // importantly have already called FEMap::init_reference_to_physical_map which will have computed
1051 // these quantities at the integration/quadrature points: phi_map, dphidxi_map,
1052 // dphideta_map, and dphidzeta_map (e.g. phi and \nabla phi w.r.t reference coordinates). *_map is
1053 // used to denote that quantities are in reference to a mapping Lagrange FE object. The FE<Dim,
1054 // LAGRANGE> objects used for mapping will in general have an order matching the order of the
1055 // mesh. These *phi*_map quantities are independent of mesh displacements when using a quadrature
1056 // rule.
1057 //
1058 // Note that a user could have specified custom integration points (e.g. independent of a
1059 // quadrature rule) which could very well depend on displacements. In that case even the *phi*_map
1060 // quantities from the above paragraph would be a function of the displacements and we would be
1061 // missing that derivative information in the calculations below
1062 //
1063 // Important quantities calculated by this method:
1064 // - _ad_JxW;
1065 // - _ad_q_points;
1066 // And the following quantities are important because they are used in the computeGradPhiAD method
1067 // to calculate the shape function gradients with respect to the physical coordinates
1068 // dphi/dphys = dphi/dref * dref/dphys:
1069 // - _ad_dxidx_map;
1070 // - _ad_dxidy_map;
1071 // - _ad_dxidz_map;
1072 // - _ad_detadx_map;
1073 // - _ad_detady_map;
1074 // - _ad_detadz_map;
1075 // - _ad_dzetadx_map;
1076 // - _ad_dzetady_map;
1077 // - _ad_dzetadz_map;
1078 //
1079 // Some final notes. This method will be called both when we are reinit'ing in the volume and on
1080 // faces. When reinit'ing on faces, computation of _ad_JxW will be garbage because we will be
1081 // using dummy quadrature weights. _ad_q_points computation is also currently extraneous during
1082 // face reinit because we compute _ad_q_points_face in the computeFaceMap method. However,
1083 // computation of dref/dphys is absolutely necessary (and the reason we call this method for the
1084 // face case) for both volume and face reinit
1085
1086 auto dim = elem->dim();
1087 const auto & elem_nodes = elem->get_nodes();
1088 const auto & phi_map = fe->get_fe_map().get_phi_map();
1089 // The mapping basis includes every mapping node, including enriched nodes on elements such as
1090 // TET14.
1091 const auto num_shapes = phi_map.size();
1092 const auto & dphidxi_map = fe->get_fe_map().get_dphidxi_map();
1093 const auto & dphideta_map = fe->get_fe_map().get_dphideta_map();
1094 const auto & dphidzeta_map = fe->get_fe_map().get_dphidzeta_map();
1095 const auto sys_num = _sys.number();
1096 const bool do_derivatives =
1097 ADReal::do_derivatives && _sys.number() == _subproblem.currentNlSysNum();
1098
1099 switch (dim)
1100 {
1101 case 0:
1102 {
1103 _ad_jac[p] = 1.0;
1104 _ad_JxW[p] = qw[p];
1105 if (_calculate_xyz)
1106 _ad_q_points[p] = *elem_nodes[0];
1107 break;
1108 }
1109
1110 case 1:
1111 {
1112 if (_calculate_xyz)
1113 _ad_q_points[p].zero();
1114
1115 _ad_dxyzdxi_map[p].zero();
1116
1117 for (std::size_t i = 0; i < num_shapes; i++)
1118 {
1119 libmesh_assert(elem_nodes[i]);
1120 const Node & node = *elem_nodes[i];
1122 if (do_derivatives)
1123 for (const auto & [disp_num, direction] : _disp_numbers_and_directions)
1124 if (node.n_dofs(sys_num, disp_num))
1126 elem_point(direction).derivatives(), node.dof_number(sys_num, disp_num, 0), 1.);
1127
1128 _ad_dxyzdxi_map[p].add_scaled(elem_point, dphidxi_map[i][p]);
1129
1130 if (_calculate_xyz)
1131 _ad_q_points[p].add_scaled(elem_point, phi_map[i][p]);
1132 }
1133
1134 _ad_jac[p] = _ad_dxyzdxi_map[p].norm();
1135
1136 if (_ad_jac[p].value() <= -TOLERANCE * TOLERANCE)
1137 {
1138 static bool failing = false;
1139 if (!failing)
1140 {
1141 failing = true;
1142 elem->print_info(libMesh::err);
1143 libmesh_error_msg("ERROR: negative Jacobian " << _ad_jac[p].value() << " at point index "
1144 << p << " in element " << elem->id());
1145 }
1146 else
1147 return;
1148 }
1149
1150 const auto jacm2 = 1. / _ad_jac[p] / _ad_jac[p];
1151 _ad_dxidx_map[p] = jacm2 * _ad_dxyzdxi_map[p](0);
1152 _ad_dxidy_map[p] = jacm2 * _ad_dxyzdxi_map[p](1);
1153 _ad_dxidz_map[p] = jacm2 * _ad_dxyzdxi_map[p](2);
1154
1155 _ad_JxW[p] = _ad_jac[p] * qw[p];
1156
1157 break;
1158 }
1159
1160 case 2:
1161 {
1162 if (_calculate_xyz)
1163 _ad_q_points[p].zero();
1164 _ad_dxyzdxi_map[p].zero();
1165 _ad_dxyzdeta_map[p].zero();
1166
1167 for (std::size_t i = 0; i < num_shapes; i++)
1168 {
1169 libmesh_assert(elem_nodes[i]);
1170 const Node & node = *elem_nodes[i];
1172 if (do_derivatives)
1173 for (const auto & [disp_num, direction] : _disp_numbers_and_directions)
1174 if (node.n_dofs(sys_num, disp_num))
1176 elem_point(direction).derivatives(), node.dof_number(sys_num, disp_num, 0), 1.);
1177
1178 _ad_dxyzdxi_map[p].add_scaled(elem_point, dphidxi_map[i][p]);
1179 _ad_dxyzdeta_map[p].add_scaled(elem_point, dphideta_map[i][p]);
1180
1181 if (_calculate_xyz)
1182 _ad_q_points[p].add_scaled(elem_point, phi_map[i][p]);
1183 }
1184
1185 const auto &dx_dxi = _ad_dxyzdxi_map[p](0), &dx_deta = _ad_dxyzdeta_map[p](0),
1186 &dy_dxi = _ad_dxyzdxi_map[p](1), &dy_deta = _ad_dxyzdeta_map[p](1),
1187 &dz_dxi = _ad_dxyzdxi_map[p](2), &dz_deta = _ad_dxyzdeta_map[p](2);
1188
1189 const auto g11 = (dx_dxi * dx_dxi + dy_dxi * dy_dxi + dz_dxi * dz_dxi);
1190
1191 const auto g12 = (dx_dxi * dx_deta + dy_dxi * dy_deta + dz_dxi * dz_deta);
1192
1193 const auto & g21 = g12;
1194
1195 const auto g22 = (dx_deta * dx_deta + dy_deta * dy_deta + dz_deta * dz_deta);
1196
1197 auto det = (g11 * g22 - g12 * g21);
1198
1199 if (det.value() <= -TOLERANCE * TOLERANCE)
1200 {
1201 static bool failing = false;
1202 if (!failing)
1203 {
1204 failing = true;
1205 elem->print_info(libMesh::err);
1206 libmesh_error_msg("ERROR: negative Jacobian " << det << " at point index " << p
1207 << " in element " << elem->id());
1208 }
1209 else
1210 return;
1211 }
1212 else if (det.value() <= 0.)
1213 det.value() = TOLERANCE * TOLERANCE;
1214
1215 const auto inv_det = 1. / det;
1216 using std::sqrt;
1217 _ad_jac[p] = sqrt(det);
1218
1219 _ad_JxW[p] = _ad_jac[p] * qw[p];
1220
1221 const auto g11inv = g22 * inv_det;
1222 const auto g12inv = -g12 * inv_det;
1223 const auto g21inv = -g21 * inv_det;
1224 const auto g22inv = g11 * inv_det;
1225
1226 _ad_dxidx_map[p] = g11inv * dx_dxi + g12inv * dx_deta;
1227 _ad_dxidy_map[p] = g11inv * dy_dxi + g12inv * dy_deta;
1228 _ad_dxidz_map[p] = g11inv * dz_dxi + g12inv * dz_deta;
1229
1230 _ad_detadx_map[p] = g21inv * dx_dxi + g22inv * dx_deta;
1231 _ad_detady_map[p] = g21inv * dy_dxi + g22inv * dy_deta;
1232 _ad_detadz_map[p] = g21inv * dz_dxi + g22inv * dz_deta;
1233
1234 break;
1235 }
1236
1237 case 3:
1238 {
1239 if (_calculate_xyz)
1240 _ad_q_points[p].zero();
1241 _ad_dxyzdxi_map[p].zero();
1242 _ad_dxyzdeta_map[p].zero();
1243 _ad_dxyzdzeta_map[p].zero();
1244
1245 for (std::size_t i = 0; i < num_shapes; i++)
1246 {
1247 libmesh_assert(elem_nodes[i]);
1248 const Node & node = *elem_nodes[i];
1250 if (do_derivatives)
1251 for (const auto & [disp_num, direction] : _disp_numbers_and_directions)
1252 if (node.n_dofs(sys_num, disp_num))
1254 elem_point(direction).derivatives(), node.dof_number(sys_num, disp_num, 0), 1.);
1255
1256 _ad_dxyzdxi_map[p].add_scaled(elem_point, dphidxi_map[i][p]);
1257 _ad_dxyzdeta_map[p].add_scaled(elem_point, dphideta_map[i][p]);
1258 _ad_dxyzdzeta_map[p].add_scaled(elem_point, dphidzeta_map[i][p]);
1259
1260 if (_calculate_xyz)
1261 _ad_q_points[p].add_scaled(elem_point, phi_map[i][p]);
1262 }
1263
1264 const auto &dx_dxi = _ad_dxyzdxi_map[p](0), &dy_dxi = _ad_dxyzdxi_map[p](1),
1265 &dz_dxi = _ad_dxyzdxi_map[p](2), &dx_deta = _ad_dxyzdeta_map[p](0),
1266 &dy_deta = _ad_dxyzdeta_map[p](1), &dz_deta = _ad_dxyzdeta_map[p](2),
1267 &dx_dzeta = _ad_dxyzdzeta_map[p](0), &dy_dzeta = _ad_dxyzdzeta_map[p](1),
1268 &dz_dzeta = _ad_dxyzdzeta_map[p](2);
1269
1270 _ad_jac[p] = (dx_dxi * (dy_deta * dz_dzeta - dz_deta * dy_dzeta) +
1271 dy_dxi * (dz_deta * dx_dzeta - dx_deta * dz_dzeta) +
1272 dz_dxi * (dx_deta * dy_dzeta - dy_deta * dx_dzeta));
1273
1274 if (_ad_jac[p].value() <= -TOLERANCE * TOLERANCE)
1275 {
1276 static bool failing = false;
1277 if (!failing)
1278 {
1279 failing = true;
1280 elem->print_info(libMesh::err);
1281 libmesh_error_msg("ERROR: negative Jacobian " << _ad_jac[p].value() << " at point index "
1282 << p << " in element " << elem->id());
1283 }
1284 else
1285 return;
1286 }
1287
1288 _ad_JxW[p] = _ad_jac[p] * qw[p];
1289
1290 const auto inv_jac = 1. / _ad_jac[p];
1291
1292 _ad_dxidx_map[p] = (dy_deta * dz_dzeta - dz_deta * dy_dzeta) * inv_jac;
1293 _ad_dxidy_map[p] = (dz_deta * dx_dzeta - dx_deta * dz_dzeta) * inv_jac;
1294 _ad_dxidz_map[p] = (dx_deta * dy_dzeta - dy_deta * dx_dzeta) * inv_jac;
1295
1296 _ad_detadx_map[p] = (dz_dxi * dy_dzeta - dy_dxi * dz_dzeta) * inv_jac;
1297 _ad_detady_map[p] = (dx_dxi * dz_dzeta - dz_dxi * dx_dzeta) * inv_jac;
1298 _ad_detadz_map[p] = (dy_dxi * dx_dzeta - dx_dxi * dy_dzeta) * inv_jac;
1299
1300 _ad_dzetadx_map[p] = (dy_dxi * dz_deta - dz_dxi * dy_deta) * inv_jac;
1301 _ad_dzetady_map[p] = (dz_dxi * dx_deta - dx_dxi * dz_deta) * inv_jac;
1302 _ad_dzetadz_map[p] = (dx_dxi * dy_deta - dy_dxi * dx_deta) * inv_jac;
1303
1304 break;
1305 }
1306
1307 default:
1308 libmesh_error_msg("Invalid dim = " << dim);
1309 }
1310}
std::vector< VectorValue< ADReal > > _ad_dxyzdzeta_map
Definition Assembly.h:2842
std::vector< ADReal > _ad_jac
Definition Assembly.h:2846
LIBMESH_DEVICE_INLINE auto det(const TensorLike &T_in) -> std::enable_if_t< is_tensor_like_v< TensorLike >, decltype(T_in.det())>
libmesh_assert(ctx)
OStreamProxy err(std::cerr)

Referenced by computeADFace(), and reinitFE().

◆ computingJacobian()

bool Assembly::computingJacobian ( ) const
inline
Returns
whether we are computing a Jacobian

Definition at line 1954 of file Assembly.h.

1954{ 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 1949 of file Assembly.h.

1949{ 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 1959 of file Assembly.h.

◆ constify_ref()

template<typename T >
static const T *const & Assembly::constify_ref ( T *const &  inref)
inlinestatic

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

Definition at line 112 of file Assembly.h.

113 {
114 const T * const * ptr = &inref;
115 return *ptr;
116 }

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

306{ 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.

288{ return _coord; }

◆ copyFaceShapes() [1/2]

template<typename T >
void Assembly::copyFaceShapes ( MooseVariableField< T > &  v)

Definition at line 3106 of file Assembly.C.

3107{
3108 phiFace(v).shallowCopy(v.phiFace());
3109 gradPhiFace(v).shallowCopy(v.gradPhiFace());
3110 if (v.computingSecond())
3111 secondPhiFace(v).shallowCopy(v.secondPhiFace());
3112}
const VariablePhiValue & phiFace() const
Definition Assembly.h:1332
const VariablePhiGradient & gradPhiFace() const
Definition Assembly.h:1334
const VariablePhiSecond & secondPhiFace(const MooseVariableField< Real > &) const
Definition Assembly.h:1339
virtual const FieldVariablePhiGradient & gradPhiFace() const =0
Return the gradients of the variable's shape functions on an element face.
virtual const FieldVariablePhiSecond & secondPhiFace() const =0
Return the rank-2 tensor of second derivatives of the variable's shape functions on an element face.
virtual bool computingSecond() const =0
Whether or not this variable is computing any second derivatives.
virtual const FieldVariablePhiValue & phiFace() const =0
Return the variable's shape functions on an element face.

Referenced by copyFaceShapes().

◆ copyFaceShapes() [2/2]

void Assembly::copyFaceShapes ( unsigned int  var)

Definition at line 3115 of file Assembly.C.

3116{
3117 auto & v = _sys.getVariable(_tid, var);
3118 if (v.fieldType() == Moose::VarFieldType::VAR_FIELD_STANDARD)
3119 {
3120 auto & v = _sys.getActualFieldVariable<Real>(_tid, var);
3121 copyFaceShapes(v);
3122 }
3123 else if (v.fieldType() == Moose::VarFieldType::VAR_FIELD_ARRAY)
3124 {
3126 copyFaceShapes(v);
3127 }
3128 else if (v.fieldType() == Moose::VarFieldType::VAR_FIELD_VECTOR)
3129 {
3131 copyFaceShapes(v);
3132 if (v.computingCurl())
3133 _vector_curl_phi_face.shallowCopy(v.curlPhi());
3134 if (v.computingDiv())
3135 _vector_div_phi_face.shallowCopy(v.divPhi());
3136 }
3137 else
3138 mooseError("Unsupported variable field type!");
3139}
void copyFaceShapes(MooseVariableField< T > &v)
Definition Assembly.C:3106
VectorVariablePhiCurl _vector_curl_phi_face
Definition Assembly.h:2728
VectorVariablePhiDivergence _vector_div_phi_face
Definition Assembly.h:2729
MooseVariableField< T > & getActualFieldVariable(THREAD_ID tid, const std::string &var_name)
Returns a field variable pointer - this includes finite volume variables.
Definition SystemBase.C:120
@ VAR_FIELD_STANDARD
Definition MooseTypes.h:781
@ VAR_FIELD_ARRAY
Definition MooseTypes.h:784
@ VAR_FIELD_VECTOR
Definition MooseTypes.h:783
VectorValue< Real > RealVectorValue
Definition SubProblem.h:34
Eigen::Matrix< Real, Eigen::Dynamic, 1 > RealEigenVector
Definition MooseTypes.h:147
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real

◆ copyNeighborShapes() [1/2]

template<typename T >
void Assembly::copyNeighborShapes ( MooseVariableField< T > &  v)

Definition at line 3143 of file Assembly.C.

3144{
3145 if (v.usesPhiNeighbor())
3146 {
3147 phiFaceNeighbor(v).shallowCopy(v.phiFaceNeighbor());
3148 phiNeighbor(v).shallowCopy(v.phiNeighbor());
3149 }
3150 if (v.usesGradPhiNeighbor())
3151 {
3152 gradPhiFaceNeighbor(v).shallowCopy(v.gradPhiFaceNeighbor());
3153 gradPhiNeighbor(v).shallowCopy(v.gradPhiNeighbor());
3154 }
3155 if (v.usesSecondPhiNeighbor())
3156 {
3157 secondPhiFaceNeighbor(v).shallowCopy(v.secondPhiFaceNeighbor());
3158 secondPhiNeighbor(v).shallowCopy(v.secondPhiNeighbor());
3159 }
3160}
const VariablePhiSecond & secondPhiNeighbor(const MooseVariableField< Real > &) const
Definition Assembly.h:1352
const VariablePhiGradient & gradPhiNeighbor(const MooseVariableField< Real > &) const
Definition Assembly.h:1348
const VariablePhiGradient & gradPhiFaceNeighbor(const MooseVariableField< Real > &) const
Definition Assembly.h:1361
const VariablePhiSecond & secondPhiFaceNeighbor(const MooseVariableField< Real > &) const
Definition Assembly.h:1365
const VariablePhiValue & phiNeighbor(const MooseVariableField< Real > &) const
Definition Assembly.h:1344
const VariablePhiValue & phiFaceNeighbor(const MooseVariableField< Real > &) const
Definition Assembly.h:1357
virtual const FieldVariablePhiGradient & gradPhiFaceNeighbor() const =0
Return the gradients of the variable's shape functions on a neighboring element face.
virtual const FieldVariablePhiGradient & gradPhiNeighbor() const =0
Return the gradients of the variable's shape functions on a neighboring element.
virtual const FieldVariablePhiValue & phiFaceNeighbor() const =0
Return the variable's shape functions on a neighboring element face.
bool usesPhiNeighbor() const
Whether or not this variable is actually using the shape function value.
virtual const FieldVariablePhiSecond & secondPhiFaceNeighbor() const =0
Return the rank-2 tensor of second derivatives of the variable's shape functions on a neighboring ele...
virtual const FieldVariablePhiSecond & secondPhiNeighbor() const =0
Return the rank-2 tensor of second derivatives of the variable's shape functions on a neighboring ele...
virtual bool usesSecondPhiNeighbor() const =0
Whether or not this variable is actually using the shape function second derivatives.
virtual const FieldVariablePhiValue & phiNeighbor() const =0
Return the variable's shape functions on a neighboring element.
bool usesGradPhiNeighbor() const
Whether or not this variable is actually using the shape function gradient.

Referenced by copyNeighborShapes().

◆ copyNeighborShapes() [2/2]

void Assembly::copyNeighborShapes ( unsigned int  var)

Definition at line 3163 of file Assembly.C.

3164{
3165 auto & v = _sys.getVariable(_tid, var);
3166 if (v.fieldType() == Moose::VarFieldType::VAR_FIELD_STANDARD)
3167 {
3168 auto & v = _sys.getActualFieldVariable<Real>(_tid, var);
3170 }
3171 else if (v.fieldType() == Moose::VarFieldType::VAR_FIELD_ARRAY)
3172 {
3175 }
3176 else if (v.fieldType() == Moose::VarFieldType::VAR_FIELD_VECTOR)
3177 {
3180 }
3181 else
3182 mooseError("Unsupported variable field type!");
3183}
void copyNeighborShapes(MooseVariableField< T > &v)
Definition Assembly.C:3143

◆ copyShapes() [1/2]

template<typename T >
void Assembly::copyShapes ( MooseVariableField< T > &  v)

Definition at line 3069 of file Assembly.C.

3070{
3071 phi(v).shallowCopy(v.phi());
3072 gradPhi(v).shallowCopy(v.gradPhi());
3073 if (v.computingSecond())
3074 secondPhi(v).shallowCopy(v.secondPhi());
3075}
const VariablePhiGradient & gradPhi() const
Definition Assembly.h:1324
const VariablePhiValue & phi() const
Definition Assembly.h:1316
const VariablePhiSecond & secondPhi() const
Definition Assembly.h:1326
virtual const FieldVariablePhiSecond & secondPhi() const =0
Return the rank-2 tensor of second derivatives of the variable's elemental shape functions.
virtual const FieldVariablePhiValue & phi() const =0
Return the variable's elemental shape functions.
virtual const FieldVariablePhiGradient & gradPhi() const =0
Return the gradients of the variable's elemental shape functions.

Referenced by copyShapes().

◆ copyShapes() [2/2]

void Assembly::copyShapes ( unsigned int  var)

Definition at line 3078 of file Assembly.C.

3079{
3080 auto & v = _sys.getVariable(_tid, var);
3081 if (v.fieldType() == Moose::VarFieldType::VAR_FIELD_STANDARD)
3082 {
3083 auto & v = _sys.getActualFieldVariable<Real>(_tid, var);
3084 copyShapes(v);
3085 }
3086 else if (v.fieldType() == Moose::VarFieldType::VAR_FIELD_ARRAY)
3087 {
3089 copyShapes(v);
3090 }
3091 else if (v.fieldType() == Moose::VarFieldType::VAR_FIELD_VECTOR)
3092 {
3094 copyShapes(v);
3095 if (v.computingCurl())
3096 curlPhi(v).shallowCopy(v.curlPhi());
3097 if (v.computingDiv())
3098 divPhi(v).shallowCopy(v.divPhi());
3099 }
3100 else
3101 mooseError("Unsupported variable field type!");
3102}
const VectorVariablePhiDivergence & divPhi(const MooseVariableField< RealVectorValue > &) const
Definition Assembly.h:1386
const VectorVariablePhiCurl & curlPhi(const MooseVariableField< RealVectorValue > &) const
Definition Assembly.h:1382
void copyShapes(MooseVariableField< T > &v)
Definition Assembly.C:3069

◆ couplingEntries() [1/2]

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

Definition at line 1290 of file Assembly.h.

1291 {
1292 return _cm_ff_entry;
1293 }

Referenced by MortarConstraint::computeJacobian().

◆ couplingEntries() [2/2]

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

Definition at line 1295 of file Assembly.h.

1296 {
1297 return _cm_ff_entry;
1298 }

◆ createQRules()

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

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

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

Definition at line 654 of file Assembly.C.

660{
661 auto & qvec = _qrules[block];
662 unsigned int ndims = _mesh_dimension + 1; // must account for 0-dimensional quadrature.
663 if (qvec.size() != ndims)
664 qvec.resize(ndims);
665
666 for (unsigned int i = 0; i < qvec.size(); i++)
667 {
668 int dim = i;
669 auto & q = qvec[dim];
670 q.vol = QBase::build(type, dim, volume_order);
671 q.vol->allow_rules_with_negative_weights = allow_negative_qweights;
672 q.face = QBase::build(type, dim - 1, face_order);
673 q.face->allow_rules_with_negative_weights = allow_negative_qweights;
674 q.fv_face = QBase::build(libMesh::QMONOMIAL, dim - 1, CONSTANT);
675 q.fv_face->allow_rules_with_negative_weights = allow_negative_qweights;
676 q.neighbor = std::make_unique<ArbitraryQuadrature>(dim - 1, face_order);
677 q.neighbor->allow_rules_with_negative_weights = allow_negative_qweights;
678 q.arbitrary_vol = std::make_unique<ArbitraryQuadrature>(dim, order);
679 q.arbitrary_vol->allow_rules_with_negative_weights = allow_negative_qweights;
680 q.arbitrary_face = std::make_unique<ArbitraryQuadrature>(dim - 1, face_order);
681 q.arbitrary_face->allow_rules_with_negative_weights = allow_negative_qweights;
682 }
683
684 delete _qrule_msm;
685 _custom_mortar_qrule = false;
686 _qrule_msm = QBase::build(type, _mesh_dimension - 1, face_order).release();
687 _qrule_msm->allow_rules_with_negative_weights = allow_negative_qweights;
688 _fe_msm->attach_quadrature_rule(_qrule_msm);
689}
bool allow_rules_with_negative_weights

Referenced by bumpAllQRuleOrder(), and bumpVolumeQRuleOrder().

◆ curlPhi() [1/2]

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

Definition at line 1503 of file Assembly.h.

1504 {
1505 return _vector_curl_phi;
1506 }
VectorVariablePhiCurl _vector_curl_phi
Definition Assembly.h:2722

◆ curlPhi() [2/2]

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

Definition at line 1382 of file Assembly.h.

1383 {
1384 return _vector_curl_phi;
1385 }

Referenced by copyShapes().

◆ curlPhiFace() [1/2]

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

Definition at line 1524 of file Assembly.h.

1525 {
1526 return _vector_curl_phi_face;
1527 }

◆ curlPhiFace() [2/2]

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

Definition at line 1403 of file Assembly.h.

1404 {
1405 return _vector_curl_phi_face;
1406 }

◆ curlPhiFaceNeighbor() [1/2]

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

Definition at line 1565 of file Assembly.h.

1566 {
1568 }
VectorVariablePhiCurl _vector_curl_phi_face_neighbor
Definition Assembly.h:2740

◆ curlPhiFaceNeighbor() [2/2]

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

Definition at line 1451 of file Assembly.h.

1452 {
1454 }

◆ curlPhiNeighbor() [1/2]

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

Definition at line 1545 of file Assembly.h.

1546 {
1548 }
VectorVariablePhiCurl _vector_curl_phi_neighbor
Definition Assembly.h:2734

◆ curlPhiNeighbor() [2/2]

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

Definition at line 1426 of file Assembly.h.

1427 {
1429 }

◆ currentBoundaryID()

const BoundaryID & Assembly::currentBoundaryID ( ) const
inline

Return the current boundary ID.

Definition at line 425 of file Assembly.h.

425{ return _current_boundary_id; }
BoundaryID _current_boundary_id
The current boundary ID.
Definition Assembly.h:2599

◆ currentNeighborSubdomainID()

const SubdomainID & Assembly::currentNeighborSubdomainID ( ) const
inline

Return the current subdomain ID.

Definition at line 493 of file Assembly.h.

SubdomainID _current_neighbor_subdomain_id
The current neighbor subdomain ID.
Definition Assembly.h:2611

◆ currentSubdomainID()

const SubdomainID & Assembly::currentSubdomainID ( ) const
inline

Return the current subdomain ID.

Definition at line 415 of file Assembly.h.

415{ return _current_subdomain_id; }
SubdomainID _current_subdomain_id
The current subdomain ID.
Definition Assembly.h:2597

Referenced by PiecewiseConstantFromCSV::value().

◆ divPhi() [1/2]

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

Definition at line 1507 of file Assembly.h.

1508 {
1509 return _vector_div_phi;
1510 }
VectorVariablePhiDivergence _vector_div_phi
Definition Assembly.h:2723

◆ divPhi() [2/2]

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

Definition at line 1386 of file Assembly.h.

1387 {
1388 return _vector_div_phi;
1389 }

Referenced by copyShapes().

◆ divPhiFace() [1/2]

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

Definition at line 1528 of file Assembly.h.

1529 {
1530 return _vector_div_phi_face;
1531 }

◆ divPhiFace() [2/2]

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

Definition at line 1407 of file Assembly.h.

1408 {
1409 return _vector_div_phi_face;
1410 }

◆ divPhiFaceNeighbor() [1/2]

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

Definition at line 1569 of file Assembly.h.

1570 {
1572 }
VectorVariablePhiDivergence _vector_div_phi_face_neighbor
Definition Assembly.h:2741

◆ divPhiFaceNeighbor() [2/2]

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

Definition at line 1456 of file Assembly.h.

1457 {
1459 }

◆ divPhiNeighbor() [1/2]

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

Definition at line 1549 of file Assembly.h.

1550 {
1552 }
VectorVariablePhiDivergence _vector_div_phi_neighbor
Definition Assembly.h:2735

◆ divPhiNeighbor() [2/2]

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

Definition at line 1431 of file Assembly.h.

1432 {
1434 }

◆ elem()

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

◆ elementVolume()

Real Assembly::elementVolume ( const Elem *  elem) const

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

Definition at line 3823 of file Assembly.C.

3824{
3825 FEType fe_type(elem->default_order(), LAGRANGE);
3826 std::unique_ptr<FEBase> fe(FEBase::build(elem->dim(), fe_type));
3827
3828 // references to the quadrature points and weights
3829 const std::vector<Real> & JxW = fe->get_JxW();
3830 const std::vector<Point> & q_points = fe->get_xyz();
3831
3832 // The default quadrature rule should integrate the mass matrix,
3833 // thus it should be plenty to compute the volume
3834 QGauss qrule(elem->dim(), fe_type.default_quadrature_order());
3835 fe->attach_quadrature_rule(&qrule);
3836 fe->reinit(elem);
3837
3838 // perform a sanity check to ensure that size of quad rule and size of q_points is
3839 // identical
3840 mooseAssert(qrule.n_points() == q_points.size(),
3841 "The number of points in the quadrature rule doesn't match the number of passed-in "
3842 "points in Assembly::setCoordinateTransformation");
3843
3844 // compute the coordinate transformation
3845 Real vol = 0;
3846 for (unsigned int qp = 0; qp < qrule.n_points(); ++qp)
3847 {
3848 Real coord;
3849 coordTransformFactor(_subproblem, elem->subdomain_id(), q_points[qp], coord);
3850 vol += JxW[qp] * coord;
3851 }
3852 return vol;
3853}
void coordTransformFactor(const SubProblem &s, SubdomainID sub_id, const P &point, C &factor, SubdomainID neighbor_sub_id=libMesh::Elem::invalid_subdomain_id)
Computes a conversion multiplier for use when computing integraals for the current coordinate system ...
Definition Assembly.C:41
const MooseArray< Real > & JxW() const
Returns the reference to the transformed jacobian weights.
Definition Assembly.h:268

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

◆ elemVolume()

const Real & Assembly::elemVolume ( ) const
inline

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

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

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

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

◆ feADGradPhi() [1/2]

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

Definition at line 1630 of file Assembly.h.

1631 {
1632 return _ad_grad_phi_data[type];
1633 }

◆ feADGradPhi() [2/2]

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

Definition at line 2965 of file Assembly.h.

2967{
2968 return _ad_vector_grad_phi_data[type];
2969}

◆ feADGradPhiFace() [1/2]

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

Definition at line 1671 of file Assembly.h.

1672 {
1673 return _ad_grad_phi_data_face[type];
1674 }

◆ feADGradPhiFace() [2/2]

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

Definition at line 2972 of file Assembly.h.

2974{
2975 return _ad_vector_grad_phi_data_face[type];
2976}

◆ feCurlPhi() [1/3]

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

Definition at line 1743 of file Assembly.h.

1744 {
1745 _need_curl.insert(type);
1746 buildFE(type);
1747 return _fe_shape_data[type]->_curl_phi;
1748 }

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

4774{
4775 _need_curl.insert(type);
4776 buildVectorFE(type);
4777 return _vector_fe_shape_data[type]->_curl_phi;
4778}
void buildVectorFE(FEType type) const
Build Vector FEs with a type.
Definition Assembly.C:478

◆ feCurlPhiFace() [1/3]

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

Definition at line 1751 of file Assembly.h.

1752 {
1753 _need_curl.insert(type);
1754 buildFaceFE(type);
1755 return _fe_shape_data_face[type]->_curl_phi;
1756 }

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

4783{
4784 _need_curl.insert(type);
4785 buildVectorFaceFE(type);
4786
4787 // If we're building for a face we probably need to build for a
4788 // neighbor while _need_curl is set;
4789 // onInterface/reinitNeighbor/etc don't distinguish
4791
4792 return _vector_fe_shape_data_face[type]->_curl_phi;
4793}
void buildVectorFaceNeighborFE(FEType type) const
Build Vector FEs for a neighbor face with a type.
Definition Assembly.C:578
void buildVectorFaceFE(FEType type) const
Build Vector FEs for a face with a type.
Definition Assembly.C:512

◆ feCurlPhiFaceNeighbor() [1/3]

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

Definition at line 1767 of file Assembly.h.

1768 {
1769 _need_curl.insert(type);
1770 buildFaceNeighborFE(type);
1771 return _fe_shape_data_face_neighbor[type]->_curl_phi;
1772 }

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

4807{
4808 _need_curl.insert(type);
4810
4811 return _vector_fe_shape_data_face_neighbor[type]->_curl_phi;
4812}

◆ feCurlPhiNeighbor() [1/3]

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

Definition at line 1759 of file Assembly.h.

1760 {
1761 _need_curl.insert(type);
1762 buildNeighborFE(type);
1763 return _fe_shape_data_neighbor[type]->_curl_phi;
1764 }

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

4798{
4799 _need_curl.insert(type);
4801 return _vector_fe_shape_data_neighbor[type]->_curl_phi;
4802}
void buildVectorNeighborFE(FEType type) const
Build Vector FEs for a neighbor with a type.
Definition Assembly.C:545

◆ feDivPhi() [1/3]

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

Definition at line 1775 of file Assembly.h.

1776 {
1777 buildFE(type);
1778 return _fe_shape_data[type]->_div_phi;
1779 }

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

4817{
4818 _need_div.insert(type);
4819 buildVectorFE(type);
4820 return _vector_fe_shape_data[type]->_div_phi;
4821}

◆ feDivPhiFace() [1/3]

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

Definition at line 1782 of file Assembly.h.

1783 {
1784 buildFaceFE(type);
1785 return _fe_shape_data_face[type]->_div_phi;
1786 }

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

4826{
4827 _need_face_div.insert(type);
4828 buildVectorFaceFE(type);
4829
4830 // If we're building for a face we probably need to build for a
4831 // neighbor while _need_face_div is set;
4832 // onInterface/reinitNeighbor/etc don't distinguish
4834
4835 return _vector_fe_shape_data_face[type]->_div_phi;
4836}

◆ feDivPhiFaceNeighbor() [1/3]

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

Definition at line 1798 of file Assembly.h.

1799 {
1800 buildFaceNeighborFE(type);
1801 return _fe_shape_data_face_neighbor[type]->_div_phi;
1802 }

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

4850{
4851 _need_face_neighbor_div.insert(type);
4853 return _vector_fe_shape_data_face_neighbor[type]->_div_phi;
4854}

◆ feDivPhiNeighbor() [1/3]

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

Definition at line 1790 of file Assembly.h.

1791 {
1792 buildNeighborFE(type);
1793 return _fe_shape_data_neighbor[type]->_div_phi;
1794 }

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

4841{
4842 _need_neighbor_div.insert(type);
4844 return _vector_fe_shape_data_neighbor[type]->_div_phi;
4845}

◆ feDualPhiLower() [1/3]

template<typename OutputType >
const OutputTools< OutputType >::VariablePhiValue & Assembly::feDualPhiLower ( FEType  type) const

Definition at line 2942 of file Assembly.h.

2943{
2944 buildLowerDDualFE(type);
2945 return _fe_shape_data_dual_lower[type]->_phi;
2946}
void buildLowerDDualFE(FEType type) const
Definition Assembly.C:398

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

4669{
4671 return _vector_fe_shape_data_dual_lower[type]->_phi;
4672}
void buildVectorDualLowerDFE(FEType type) const
Definition Assembly.C:450

◆ feGradDualPhiLower() [1/3]

template<typename OutputType >
const OutputTools< OutputType >::VariablePhiGradient & Assembly::feGradDualPhiLower ( FEType  type) const

Definition at line 2958 of file Assembly.h.

2959{
2960 buildLowerDDualFE(type);
2961 return _fe_shape_data_dual_lower[type]->_grad_phi;
2962}

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

4685{
4687 return _vector_fe_shape_data_dual_lower[type]->_grad_phi;
4688}

◆ feGradPhi() [1/3]

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

Definition at line 1623 of file Assembly.h.

1624 {
1625 buildFE(type);
1626 return _fe_shape_data[type]->_grad_phi;
1627 }

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

4644{
4645 buildVectorFE(type);
4646 return _vector_fe_shape_data[type]->_grad_phi;
4647}

◆ feGradPhiFace() [1/3]

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

Definition at line 1664 of file Assembly.h.

1665 {
1666 buildFaceFE(type);
1667 return _fe_shape_data_face[type]->_grad_phi;
1668 }

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

4701{
4702 buildVectorFaceFE(type);
4703 return _vector_fe_shape_data_face[type]->_grad_phi;
4704}

◆ feGradPhiFaceNeighbor() [1/3]

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

Definition at line 1727 of file Assembly.h.

1728 {
1729 buildFaceNeighborFE(type);
1730 return _fe_shape_data_face_neighbor[type]->_grad_phi;
1731 }

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

4757{
4759 return _vector_fe_shape_data_face_neighbor[type]->_grad_phi;
4760}

◆ feGradPhiLower() [1/3]

template<typename OutputType >
const OutputTools< OutputType >::VariablePhiGradient & Assembly::feGradPhiLower ( FEType  type) const

Definition at line 2950 of file Assembly.h.

2951{
2952 buildLowerDFE(type);
2953 return _fe_shape_data_lower[type]->_grad_phi;
2954}

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

4677{
4678 buildVectorLowerDFE(type);
4679 return _vector_fe_shape_data_lower[type]->_grad_phi;
4680}
void buildVectorLowerDFE(FEType type) const
Build Vector FEs for a lower dimensional element with a type.
Definition Assembly.C:422

◆ feGradPhiNeighbor() [1/3]

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

Definition at line 1704 of file Assembly.h.

1705 {
1706 buildNeighborFE(type);
1707 return _fe_shape_data_neighbor[type]->_grad_phi;
1708 }

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

4732{
4734 return _vector_fe_shape_data_neighbor[type]->_grad_phi;
4735}

◆ fePhi() [1/3]

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

Definition at line 1616 of file Assembly.h.

1617 {
1618 buildFE(type);
1619 return _fe_shape_data[type]->_phi;
1620 }

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

4636{
4637 buildVectorFE(type);
4638 return _vector_fe_shape_data[type]->_phi;
4639}

◆ fePhiFace() [1/3]

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

Definition at line 1657 of file Assembly.h.

1658 {
1659 buildFaceFE(type);
1660 return _fe_shape_data_face[type]->_phi;
1661 }

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

4693{
4694 buildVectorFaceFE(type);
4695 return _vector_fe_shape_data_face[type]->_phi;
4696}

◆ fePhiFaceNeighbor() [1/3]

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

Definition at line 1719 of file Assembly.h.

1720 {
1721 buildFaceNeighborFE(type);
1722 return _fe_shape_data_face_neighbor[type]->_phi;
1723 }

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

4749{
4751 return _vector_fe_shape_data_face_neighbor[type]->_phi;
4752}

◆ fePhiLower() [1/3]

template<typename OutputType >
const OutputTools< OutputType >::VariablePhiValue & Assembly::fePhiLower ( FEType  type) const

Definition at line 2934 of file Assembly.h.

2935{
2936 buildLowerDFE(type);
2937 return _fe_shape_data_lower[type]->_phi;
2938}

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

4661{
4662 buildVectorLowerDFE(type);
4663 return _vector_fe_shape_data_lower[type]->_phi;
4664}

◆ fePhiNeighbor() [1/3]

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

Definition at line 1697 of file Assembly.h.

1698 {
1699 buildNeighborFE(type);
1700 return _fe_shape_data_neighbor[type]->_phi;
1701 }

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

4724{
4726 return _vector_fe_shape_data_neighbor[type]->_phi;
4727}

◆ feSecondPhi() [1/3]

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

Definition at line 1636 of file Assembly.h.

1637 {
1638 _need_second_derivative.insert(type);
1639 buildFE(type);
1640 return _fe_shape_data[type]->_second_phi;
1641 }

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

4652{
4653 _need_second_derivative.insert(type);
4654 buildVectorFE(type);
4655 return _vector_fe_shape_data[type]->_second_phi;
4656}

◆ feSecondPhiFace() [1/3]

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

Definition at line 1689 of file Assembly.h.

1690 {
1691 _need_second_derivative.insert(type);
1692 buildFaceFE(type);
1693 return _fe_shape_data_face[type]->_second_phi;
1694 }

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

4709{
4710 _need_second_derivative.insert(type);
4711 buildVectorFaceFE(type);
4712
4713 // If we're building for a face we probably need to build for a
4714 // neighbor while _need_second_derivative is set;
4715 // onInterface/reinitNeighbor/etc don't distinguish
4717
4718 return _vector_fe_shape_data_face[type]->_second_phi;
4719}

◆ feSecondPhiFaceNeighbor() [1/3]

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

Definition at line 1735 of file Assembly.h.

1736 {
1738 buildFaceNeighborFE(type);
1739 return _fe_shape_data_face_neighbor[type]->_second_phi;
1740 }

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

4765{
4768 return _vector_fe_shape_data_face_neighbor[type]->_second_phi;
4769}

◆ feSecondPhiNeighbor() [1/3]

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

Definition at line 1711 of file Assembly.h.

1712 {
1714 buildNeighborFE(type);
1715 return _fe_shape_data_neighbor[type]->_second_phi;
1716 }

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

4740{
4743 return _vector_fe_shape_data_neighbor[type]->_second_phi;
4744}

◆ fieldScalarCouplingEntries()

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

Definition at line 1305 of file Assembly.h.

1306 {
1307 return _cm_fs_entry;
1308 }

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

4993{
4994 return qPoints();
4995}
const MooseArray< Point > & qPoints() const
Returns the reference to the quadrature points.
Definition Assembly.h:250

◆ genericQPoints() [3/3]

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

Definition at line 4998 of file Assembly.C.

5000{
5001 return adQPoints();
5002}
const MooseArray< ADPoint > & adQPoints() const
Definition Assembly.h:389

◆ 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
typeThe type of FE
dimThe dimension of the current volume
Returns
A reference to the pointer. Make sure to store this as a reference!

Definition at line 124 of file Assembly.h.

125 {
126 buildFE(type);
127 return constify_ref(_fe[dim][type]);
128 }
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-refe...
Definition Assembly.h:112

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
typeThe type of FE
dimThe dimension of the current face
Returns
A reference to the pointer. Make sure to store this as a reference!

Definition at line 148 of file Assembly.h.

149 {
150 buildFaceFE(type);
151 return constify_ref(_fe_face[dim][type]);
152 }

◆ 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
typeThe type of FE
dimThe dimension of the neighbor face
Returns
A reference to the pointer. Make sure to store this as a reference!

Definition at line 160 of file Assembly.h.

161 {
163 return constify_ref(_fe_face_neighbor[dim][type]);
164 }

◆ 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
typeThe type of FE
dimThe dimension of the current volume
Returns
A reference to the pointer. Make sure to store this as a reference!

Definition at line 136 of file Assembly.h.

137 {
138 buildNeighborFE(type);
139 return constify_ref(_fe_neighbor[dim][type]);
140 }

◆ getJacobianDiagonal()

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

Definition at line 1901 of file Assembly.h.

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

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
typeThe type of FEVector
dimThe dimension of the current volume
Returns
A reference to the pointer. Make sure to store this as a reference!

Definition at line 172 of file Assembly.h.

173 {
174 buildVectorFE(type);
175 return constify_ref(_vector_fe[dim][type]);
176 }

◆ 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
typeThe type of FE
dimThe dimension of the current face
Returns
A reference to the pointer. Make sure to store this as a reference!

Definition at line 196 of file Assembly.h.

197 {
198 buildVectorFaceFE(type);
199 return constify_ref(_vector_fe_face[dim][type]);
200 }

◆ 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
typeThe type of FE
dimThe dimension of the neighbor face
Returns
A reference to the pointer. Make sure to store this as a reference!

Definition at line 208 of file Assembly.h.

209 {
211 return constify_ref(_vector_fe_face_neighbor[dim][type]);
212 }

◆ 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
typeThe type of FE
dimThe dimension of the current volume
Returns
A reference to the pointer. Make sure to store this as a reference!

Definition at line 184 of file Assembly.h.

185 {
187 return constify_ref(_vector_fe_neighbor[dim][type]);
188 }

◆ gradPhi() [1/6]

const VariablePhiGradient & Assembly::gradPhi ( ) const
inline

Definition at line 1324 of file Assembly.h.

1324{ return _grad_phi; }
VariablePhiGradient _grad_phi
Definition Assembly.h:2703

Referenced by copyShapes().

◆ gradPhi() [2/6]

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

Definition at line 1463 of file Assembly.h.

1463{ return _grad_phi; }

◆ gradPhi() [3/6]

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

Definition at line 1325 of file Assembly.h.

1325{ return _grad_phi; }

◆ gradPhi() [4/6]

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

Definition at line 1576 of file Assembly.h.

1576{ return _grad_phi; }

◆ gradPhi() [5/6]

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

Definition at line 1495 of file Assembly.h.

1496 {
1497 return _vector_grad_phi;
1498 }
VectorVariablePhiGradient _vector_grad_phi
Definition Assembly.h:2720

◆ gradPhi() [6/6]

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

Definition at line 1374 of file Assembly.h.

1375 {
1376 return _vector_grad_phi;
1377 }

◆ gradPhiFace() [1/6]

const VariablePhiGradient & Assembly::gradPhiFace ( ) const
inline

Definition at line 1334 of file Assembly.h.

1334{ return _grad_phi_face; }
VariablePhiGradient _grad_phi_face
Definition Assembly.h:2707

Referenced by copyFaceShapes().

◆ gradPhiFace() [2/6]

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

Definition at line 1467 of file Assembly.h.

1467{ return _grad_phi_face; }

◆ gradPhiFace() [3/6]

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

Definition at line 1335 of file Assembly.h.

1336 {
1337 return _grad_phi_face;
1338 }

◆ gradPhiFace() [4/6]

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

Definition at line 1580 of file Assembly.h.

1581 {
1582 return _grad_phi_face;
1583 }

◆ gradPhiFace() [5/6]

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

Definition at line 1516 of file Assembly.h.

1517 {
1518 return _vector_grad_phi_face;
1519 }
VectorVariablePhiGradient _vector_grad_phi_face
Definition Assembly.h:2726

◆ gradPhiFace() [6/6]

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

Definition at line 1395 of file Assembly.h.

1396 {
1397 return _vector_grad_phi_face;
1398 }

◆ gradPhiFaceNeighbor() [1/5]

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

Definition at line 1484 of file Assembly.h.

1485 {
1487 }
VariablePhiGradient _grad_phi_face_neighbor
Definition Assembly.h:2715

◆ gradPhiFaceNeighbor() [2/5]

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

Definition at line 1361 of file Assembly.h.

1362 {
1364 }

Referenced by copyNeighborShapes().

◆ gradPhiFaceNeighbor() [3/5]

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

Definition at line 1606 of file Assembly.h.

1607 {
1609 }

◆ gradPhiFaceNeighbor() [4/5]

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

Definition at line 1557 of file Assembly.h.

1558 {
1560 }
VectorVariablePhiGradient _vector_grad_phi_face_neighbor
Definition Assembly.h:2738

◆ gradPhiFaceNeighbor() [5/5]

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

Definition at line 1441 of file Assembly.h.

1442 {
1444 }

◆ gradPhiNeighbor() [1/5]

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

Definition at line 1471 of file Assembly.h.

1472 {
1473 return _grad_phi_neighbor;
1474 }
VariablePhiGradient _grad_phi_neighbor
Definition Assembly.h:2711

◆ gradPhiNeighbor() [2/5]

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

Definition at line 1348 of file Assembly.h.

1349 {
1350 return _grad_phi_neighbor;
1351 }

Referenced by copyNeighborShapes().

◆ gradPhiNeighbor() [3/5]

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

Definition at line 1593 of file Assembly.h.

1594 {
1595 return _grad_phi_neighbor;
1596 }

◆ gradPhiNeighbor() [4/5]

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

Definition at line 1537 of file Assembly.h.

1538 {
1540 }
VectorVariablePhiGradient _vector_grad_phi_neighbor
Definition Assembly.h:2732

◆ gradPhiNeighbor() [5/5]

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

Definition at line 1417 of file Assembly.h.

1418 {
1420 }

◆ helpersRequestData()

void Assembly::helpersRequestData ( )
private

request phi, dphi, xyz, JxW, etc.

data through the FE helper functions

Definition at line 4869 of file Assembly.C.

4870{
4871 for (unsigned int dim = 0; dim <= _mesh_dimension; dim++)
4872 {
4873 _holder_fe_helper[dim]->get_phi();
4874 _holder_fe_helper[dim]->get_dphi();
4875 _holder_fe_helper[dim]->get_xyz();
4876 _holder_fe_helper[dim]->get_JxW();
4877
4878 _holder_fe_face_helper[dim]->get_phi();
4879 _holder_fe_face_helper[dim]->get_dphi();
4880 _holder_fe_face_helper[dim]->get_xyz();
4881 _holder_fe_face_helper[dim]->get_JxW();
4882 _holder_fe_face_helper[dim]->get_normals();
4883
4886 _holder_fe_face_neighbor_helper[dim]->get_normals();
4887
4888 _holder_fe_neighbor_helper[dim]->get_xyz();
4889 _holder_fe_neighbor_helper[dim]->get_JxW();
4890 }
4891
4892 for (unsigned int dim = 0; dim < _mesh_dimension; dim++)
4893 {
4894 // We need these computations in order to compute correct lower-d element volumes in
4895 // curvilinear coordinates
4896 _holder_fe_lower_helper[dim]->get_xyz();
4897 _holder_fe_lower_helper[dim]->get_JxW();
4898 }
4899}

Referenced by Assembly(), and preparePRefinement().

◆ init()

void Assembly::init ( const libMesh::CouplingMatrix *  cm)

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

◆ initNonlocalCoupling()

void Assembly::initNonlocalCoupling ( )

Create pair of variables requiring nonlocal jacobian contributions.

Definition at line 2717 of file Assembly.C.

2718{
2719 _cm_nonlocal_entry.clear();
2720
2721 auto & vars = _sys.getVariables(_tid);
2722
2723 for (auto & ivar : vars)
2724 {
2725 auto i = ivar->number();
2726 auto ivar_start = _cm_nonlocal_entry.size();
2727 for (unsigned int k = 0; k < ivar->count(); ++k)
2728 {
2729 unsigned int iv = i + k;
2730 for (const auto & j : libMesh::ConstCouplingRow(iv, _nonlocal_cm))
2731 if (!_sys.isScalarVariable(j))
2732 {
2733 auto & jvar = _sys.getVariable(_tid, j);
2734 auto pair = std::make_pair(ivar, &jvar);
2735 auto c = ivar_start;
2736 // check if the pair has been pushed or not
2737 bool has_pair = false;
2738 for (; c < _cm_nonlocal_entry.size(); ++c)
2739 if (_cm_nonlocal_entry[c] == pair)
2740 {
2741 has_pair = true;
2742 break;
2743 }
2744 if (!has_pair)
2745 _cm_nonlocal_entry.push_back(pair);
2746 }
2747 }
2748 }
2749}

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

1139 {
1140 jacobianBlockUsed(tag, ivar, jvar, true);
1141 return _sub_Kee[tag][ivar][_block_diagonal_matrix ? 0 : jvar];
1142 }
std::vector< std::vector< std::vector< DenseMatrix< Number > > > > _sub_Kee
Definition Assembly.h:2678

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

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

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

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

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

3232{
3233 jacobianBlockLowerUsed(tag, ivar, jvar, true);
3235 {
3236 switch (type)
3237 {
3238 default:
3239 case Moose::LowerLower:
3240 return _sub_Kll[tag][ivar][0];
3242 return _sub_Kle[tag][ivar][0];
3244 return _sub_Kln[tag][ivar][0];
3246 return _sub_Kel[tag][ivar][0];
3248 return _sub_Kee[tag][ivar][0];
3250 return _sub_Ken[tag][ivar][0];
3252 return _sub_Knl[tag][ivar][0];
3254 return _sub_Kne[tag][ivar][0];
3256 return _sub_Knn[tag][ivar][0];
3257 }
3258 }
3259 else
3260 {
3261 switch (type)
3262 {
3263 default:
3264 case Moose::LowerLower:
3265 return _sub_Kll[tag][ivar][jvar];
3267 return _sub_Kle[tag][ivar][jvar];
3269 return _sub_Kln[tag][ivar][jvar];
3271 return _sub_Kel[tag][ivar][jvar];
3273 return _sub_Kee[tag][ivar][jvar];
3275 return _sub_Ken[tag][ivar][jvar];
3277 return _sub_Knl[tag][ivar][jvar];
3279 return _sub_Kne[tag][ivar][jvar];
3281 return _sub_Knn[tag][ivar][jvar];
3282 }
3283 }
3284}
std::vector< std::vector< std::vector< DenseMatrix< Number > > > > _sub_Kll
dlower/dlower
Definition Assembly.h:2688
std::vector< std::vector< std::vector< DenseMatrix< Number > > > > _sub_Ken
jacobian contributions from the element and neighbor <Tag, ivar, jvar>
Definition Assembly.h:2682
std::vector< std::vector< std::vector< DenseMatrix< Number > > > > _sub_Kle
dlower/dsecondary (or dlower/delement)
Definition Assembly.h:2690
std::vector< std::vector< std::vector< DenseMatrix< Number > > > > _sub_Knn
jacobian contributions from the neighbor <Tag, ivar, jvar>
Definition Assembly.h:2686
std::vector< std::vector< std::vector< DenseMatrix< Number > > > > _sub_Kln
dlower/dprimary (or dlower/dneighbor)
Definition Assembly.h:2692
std::vector< std::vector< std::vector< DenseMatrix< Number > > > > _sub_Kel
dsecondary/dlower (or delement/dlower)
Definition Assembly.h:2694
std::vector< std::vector< std::vector< DenseMatrix< Number > > > > _sub_Kne
jacobian contributions from the neighbor and element <Tag, ivar, jvar>
Definition Assembly.h:2684
std::vector< std::vector< std::vector< DenseMatrix< Number > > > > _sub_Knl
dprimary/dlower (or dneighbor/dlower)
Definition Assembly.h:2696

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

3188{
3189 if (type == Moose::ElementElement)
3190 jacobianBlockUsed(tag, ivar, jvar, true);
3191 else
3192 jacobianBlockNeighborUsed(tag, ivar, jvar, true);
3193
3195 {
3196 switch (type)
3197 {
3198 default:
3200 return _sub_Kee[tag][ivar][0];
3202 return _sub_Ken[tag][ivar][0];
3204 return _sub_Kne[tag][ivar][0];
3206 return _sub_Knn[tag][ivar][0];
3207 }
3208 }
3209 else
3210 {
3211 switch (type)
3212 {
3213 default:
3215 return _sub_Kee[tag][ivar][jvar];
3217 return _sub_Ken[tag][ivar][jvar];
3219 return _sub_Kne[tag][ivar][jvar];
3221 return _sub_Knn[tag][ivar][jvar];
3222 }
3223 }
3224}
@ ElementElement
Definition MooseTypes.h:809

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

◆ jacobianBlockNeighborUsed() [1/2]

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

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

Definition at line 2265 of file Assembly.h.

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

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

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

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

1150 {
1151 jacobianBlockNonlocalUsed(tag, ivar, jvar, true);
1152 return _sub_Keg[tag][ivar][_block_diagonal_matrix ? 0 : jvar];
1153 }
std::vector< std::vector< std::vector< DenseMatrix< Number > > > > _sub_Keg
Definition Assembly.h:2679

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

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

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

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

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

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

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

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

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

◆ JxW()

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

Returns the reference to the transformed jacobian weights.

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

Definition at line 268 of file Assembly.h.

268{ 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 341 of file Assembly.h.

341{ return _current_JxW_face; }

Referenced by NonlinearThread::onInterfaceWithHRefinementMismatch().

◆ jxWMortar()

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

Returns a reference to JxW for mortar segment elements.

Definition at line 703 of file Assembly.h.

703{ return *_JxW_msm; }

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

◆ JxWNeighbor()

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

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

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

Definition at line 260 of file Assembly.C.

261{
262 _need_JxW_neighbor = true;
264}
MooseArray< Real > _current_JxW_neighbor
The current transformed jacobian weights on a neighbor's face.
Definition Assembly.h:2568

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

472{ return _current_lower_d_elem; }

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

◆ lowerDElemVolume()

const Real & Assembly::lowerDElemVolume ( ) const
inline

Definition at line 3241 of file Assembly.h.

3242{
3245}
Real _current_lower_d_elem_volume
The current lower dimensional element volume.
Definition Assembly.h:2636

◆ mappedNormals()

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

Definition at line 352 of file Assembly.h.

352{ return _mapped_normals; }
std::vector< Eigen::Map< RealDIMValue > > _mapped_normals
Mapped normals.
Definition Assembly.h:2531

◆ 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
weightsThe weights to fill into _current_JxW

Definition at line 4624 of file Assembly.C.

4625{
4626 mooseAssert(_current_qrule == _current_qrule_arbitrary, "Rule should be arbitrary");
4627 mooseAssert(weights.size() == _current_physical_points.size(), "Size mismatch");
4628
4629 for (MooseIndex(weights.size()) i = 0; i < weights.size(); ++i)
4630 _current_JxW[i] = weights[i];
4631}
unsigned int size() const
The number of elements that can currently be stored in the array.
Definition MooseArray.h:259

◆ 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
elemThe element for which the weights are adjusted
sideThe side of element for which the weights are adjusted

Definition at line 4603 of file Assembly.C.

4604{
4605 mooseAssert(_xfem != nullptr, "This function should not be called if xfem is inactive");
4606
4608 return;
4609
4610 MooseArray<Real> xfem_face_weight_multipliers;
4611 if (_xfem->getXFEMFaceWeights(
4612 xfem_face_weight_multipliers, elem, _current_qrule_face, _current_q_points_face, side))
4613 {
4614 mooseAssert(xfem_face_weight_multipliers.size() == _current_JxW_face.size(),
4615 "Size of weight multipliers in xfem doesn't match number of quadrature points");
4616 for (unsigned i = 0; i < xfem_face_weight_multipliers.size(); i++)
4617 _current_JxW_face[i] = _current_JxW_face[i] * xfem_face_weight_multipliers[i];
4618
4619 xfem_face_weight_multipliers.release();
4620 }
4621}
std::shared_ptr< XFEMInterface > _xfem
The XFEM controller.
Definition Assembly.h:2378
forward declarations
Definition MooseArray.h:18

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
elemThe element for which the weights are adjusted

Definition at line 4583 of file Assembly.C.

4584{
4585 mooseAssert(_xfem != nullptr, "This function should not be called if xfem is inactive");
4586
4588 return;
4589
4590 MooseArray<Real> xfem_weight_multipliers;
4591 if (_xfem->getXFEMWeights(xfem_weight_multipliers, elem, _current_qrule, _current_q_points))
4592 {
4593 mooseAssert(xfem_weight_multipliers.size() == _current_JxW.size(),
4594 "Size of weight multipliers in xfem doesn't match number of quadrature points");
4595 for (unsigned i = 0; i < xfem_weight_multipliers.size(); i++)
4596 _current_JxW[i] = _current_JxW[i] * xfem_weight_multipliers[i];
4597
4598 xfem_weight_multipliers.release();
4599 }
4600}

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.

294{ return _coord_msm; }

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

◆ msmElem()

const Elem *const & Assembly::msmElem ( ) const
inline
Returns
The current mortar segment element

Definition at line 1964 of file Assembly.h.

1964{ return _msm_elem; }
const Elem * _msm_elem
Definition Assembly.h:2893

◆ needADGradPhi()

void Assembly::needADGradPhi ( ) const
inline

Request that element reinitialization compute the AD shape function gradients.

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

Definition at line 1686 of file Assembly.h.

1686{ _need_ad_grad_phi = true; }

◆ needADGradPhiFace()

void Assembly::needADGradPhiFace ( ) const
inline

Request that face reinitialization compute the AD shape function gradients.

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

Definition at line 1680 of file Assembly.h.

1680{ _need_ad_grad_phi_face = true; }

◆ needDual()

bool Assembly::needDual ( ) const
inline

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

Definition at line 619 of file Assembly.h.

619{ return _need_dual; }

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

◆ neighbor()

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

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

◆ neighborLowerDElemVolume()

const Real & Assembly::neighborLowerDElemVolume ( ) const
inline

Definition at line 3248 of file Assembly.h.

3249{
3252}
Real _current_neighbor_lower_d_elem_volume
The current neighboring lower dimensional element volume.
Definition Assembly.h:2640

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

448{ 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 504 of file Assembly.h.

505 {
508 }

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

541{ 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 547 of file Assembly.h.

547{ return _current_neighbor_node; }

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

◆ nonlocalCouplingEntries()

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

Definition at line 1300 of file Assembly.h.

1301 {
1302 return _cm_nonlocal_entry;
1303 }

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

347{ return _current_normals; }

◆ numExtraElemIntegers()

unsigned int Assembly::numExtraElemIntegers ( ) const
inline

Number of extra element integers Assembly tracked.

Definition at line 363 of file Assembly.h.

363{ return _extra_elem_ids.size() - 1; }

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

◆ phi() [1/6]

const VariablePhiValue & Assembly::phi ( ) const
inline

Definition at line 1316 of file Assembly.h.

1316{ return _phi; }
VariablePhiValue _phi
Definition Assembly.h:2702

Referenced by copyShapes().

◆ phi() [2/6]

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

Definition at line 1462 of file Assembly.h.

1462{ return _phi; }

◆ phi() [3/6]

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

Definition at line 1323 of file Assembly.h.

1323{ return _phi; }

◆ phi() [4/6]

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

Definition at line 1575 of file Assembly.h.

1575{ return _phi; }

◆ phi() [5/6]

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

Definition at line 1494 of file Assembly.h.

1494{ return _vector_phi; }
VectorVariablePhiValue _vector_phi
Definition Assembly.h:2719

◆ phi() [6/6]

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

Definition at line 1370 of file Assembly.h.

1371 {
1372 return _vector_phi;
1373 }

◆ phiFace() [1/6]

const VariablePhiValue & Assembly::phiFace ( ) const
inline

Definition at line 1332 of file Assembly.h.

1332{ return _phi_face; }
VariablePhiValue _phi_face
Definition Assembly.h:2706

Referenced by copyFaceShapes().

◆ phiFace() [2/6]

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

Definition at line 1466 of file Assembly.h.

1466{ return _phi_face; }

◆ phiFace() [3/6]

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

Definition at line 1333 of file Assembly.h.

1333{ return _phi_face; }

◆ phiFace() [4/6]

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

Definition at line 1579 of file Assembly.h.

1579{ return _phi_face; }

◆ phiFace() [5/6]

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

Definition at line 1512 of file Assembly.h.

1513 {
1514 return _vector_phi_face;
1515 }
VectorVariablePhiValue _vector_phi_face
Definition Assembly.h:2725

◆ phiFace() [6/6]

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

Definition at line 1391 of file Assembly.h.

1392 {
1393 return _vector_phi_face;
1394 }

◆ phiFaceNeighbor() [1/5]

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

Definition at line 1480 of file Assembly.h.

1481 {
1482 return _phi_face_neighbor;
1483 }
VariablePhiValue _phi_face_neighbor
Definition Assembly.h:2714

◆ phiFaceNeighbor() [2/5]

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

Definition at line 1357 of file Assembly.h.

1358 {
1359 return _phi_face_neighbor;
1360 }

Referenced by copyNeighborShapes().

◆ phiFaceNeighbor() [3/5]

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

Definition at line 1602 of file Assembly.h.

1603 {
1604 return _phi_face_neighbor;
1605 }

◆ phiFaceNeighbor() [4/5]

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

Definition at line 1553 of file Assembly.h.

1554 {
1556 }
VectorVariablePhiValue _vector_phi_face_neighbor
Definition Assembly.h:2737

◆ phiFaceNeighbor() [5/5]

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

Definition at line 1436 of file Assembly.h.

1437 {
1439 }

◆ phiNeighbor() [1/5]

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

Definition at line 1470 of file Assembly.h.

1470{ return _phi_neighbor; }
VariablePhiValue _phi_neighbor
Definition Assembly.h:2710

◆ phiNeighbor() [2/5]

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

Definition at line 1344 of file Assembly.h.

1345 {
1346 return _phi_neighbor;
1347 }

Referenced by copyNeighborShapes().

◆ phiNeighbor() [3/5]

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

Definition at line 1589 of file Assembly.h.

1590 {
1591 return _phi_neighbor;
1592 }

◆ phiNeighbor() [4/5]

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

Definition at line 1533 of file Assembly.h.

1534 {
1535 return _vector_phi_neighbor;
1536 }
VectorVariablePhiValue _vector_phi_neighbor
Definition Assembly.h:2731

◆ phiNeighbor() [5/5]

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

Definition at line 1412 of file Assembly.h.

1413 {
1414 return _vector_phi_neighbor;
1415 }

◆ physicalPoints()

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

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

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

Definition at line 262 of file Assembly.h.

262{ return _current_physical_points; }

◆ prepare()

void Assembly::prepare ( )

Definition at line 2785 of file Assembly.C.

2786{
2789}
void prepareJacobianBlock()
Sizes and zeroes the Jacobian blocks used for the current element.
Definition Assembly.C:2752
void prepareResidual()
Sizes and zeroes the residual for the current element.
Definition Assembly.C:2776

◆ prepareBlock()

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

Definition at line 2968 of file Assembly.C.

2971{
2972 const auto & iv = _sys.getVariable(_tid, ivar);
2973 const auto & jv = _sys.getVariable(_tid, jvar);
2974 const unsigned int ivn = iv.number();
2975 const unsigned int jvn = jv.number();
2976 const unsigned int icount = iv.count();
2977 unsigned int jcount = jv.count();
2978 if (ivn == jvn && _component_block_diagonal[ivn])
2979 jcount = 1;
2980
2981 for (MooseIndex(_jacobian_block_used) tag = 0; tag < _jacobian_block_used.size(); tag++)
2982 {
2983 jacobianBlock(ivn, jvn, LocalDataKey{}, tag)
2984 .resize(dof_indices.size() * icount, dof_indices.size() * jcount);
2985 jacobianBlockUsed(tag, ivn, jvn, false);
2986 }
2987
2988 for (auto & tag_Re : _sub_Re)
2989 tag_Re[ivn].resize(dof_indices.size() * icount);
2990}

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

2997{
2998 const auto & iv = _sys.getVariable(_tid, ivar);
2999 const auto & jv = _sys.getVariable(_tid, jvar);
3000 const unsigned int ivn = iv.number();
3001 const unsigned int jvn = jv.number();
3002 const unsigned int icount = iv.count();
3003 unsigned int jcount = jv.count();
3004 if (ivn == jvn && _component_block_diagonal[ivn])
3005 jcount = 1;
3006
3007 for (MooseIndex(_jacobian_block_nonlocal_used) tag = 0;
3008 tag < _jacobian_block_nonlocal_used.size();
3009 tag++)
3010 {
3011 jacobianBlockNonlocal(ivn, jvn, LocalDataKey{}, tag)
3012 .resize(idof_indices.size() * icount, jdof_indices.size() * jcount);
3013
3014 jacobianBlockNonlocalUsed(tag, ivn, jvn, false);
3015 }
3016}

◆ prepareJacobianBlock()

void Assembly::prepareJacobianBlock ( )

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

Definition at line 2752 of file Assembly.C.

2753{
2754 for (const auto & it : _cm_ff_entry)
2755 {
2756 MooseVariableFEBase & ivar = *(it.first);
2757 MooseVariableFEBase & jvar = *(it.second);
2758
2759 unsigned int vi = ivar.number();
2760 unsigned int vj = jvar.number();
2761
2762 const bool array_block_diagonal_purely_diagonal = vi == vj && _component_block_diagonal[vi];
2763 auto num_cols = jvar.dofIndices().size();
2764 if (array_block_diagonal_purely_diagonal)
2765 num_cols /= jvar.count();
2766
2767 for (MooseIndex(_jacobian_block_used) tag = 0; tag < _jacobian_block_used.size(); tag++)
2768 {
2769 jacobianBlock(vi, vj, LocalDataKey{}, tag).resize(ivar.dofIndices().size(), num_cols);
2770 jacobianBlockUsed(tag, vi, vj, false);
2771 }
2772 }
2773}
This class provides an interface for common operations on field variables of both FE and FV types wit...

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

2917{
2918 for (const auto & it : _cm_ff_entry)
2919 {
2920 MooseVariableFEBase & ivar = *(it.first);
2921 MooseVariableFEBase & jvar = *(it.second);
2922
2923 unsigned int vi = ivar.number();
2924 unsigned int vj = jvar.number();
2925
2926 const bool array_block_diagonal_purely_diagonal = vi == vj && _component_block_diagonal[vi];
2927 const auto dofs_divisor = array_block_diagonal_purely_diagonal ? jvar.count() : 1;
2928
2929 for (MooseIndex(_jacobian_block_lower_used) tag = 0; tag < _jacobian_block_lower_used.size();
2930 tag++)
2931 {
2932 // To cover all possible cases we should have 9 combinations below for every 2-permutation
2933 // of Lower,Secondary,Primary. However, 4 cases will in general be covered by calls to
2934 // prepare() and prepareNeighbor(). These calls will cover SecondarySecondary
2935 // (ElementElement), SecondaryPrimary (ElementNeighbor), PrimarySecondary (NeighborElement),
2936 // and PrimaryPrimary (NeighborNeighbor). With these covered we only need to prepare the 5
2937 // remaining below
2938
2939 // derivatives w.r.t. lower dimensional residuals
2940 jacobianBlockMortar(Moose::LowerLower, vi, vj, LocalDataKey{}, tag)
2941 .resize(ivar.dofIndicesLower().size(), jvar.dofIndicesLower().size() / dofs_divisor);
2942
2943 jacobianBlockMortar(Moose::LowerSecondary, vi, vj, LocalDataKey{}, tag)
2944 .resize(ivar.dofIndicesLower().size(), jvar.dofIndices().size() / dofs_divisor);
2945
2946 jacobianBlockMortar(Moose::LowerPrimary, vi, vj, LocalDataKey{}, tag)
2947 .resize(ivar.dofIndicesLower().size(), jvar.dofIndicesNeighbor().size() / dofs_divisor);
2948
2949 // derivatives w.r.t. interior secondary residuals
2950 jacobianBlockMortar(Moose::SecondaryLower, vi, vj, LocalDataKey{}, tag)
2951 .resize(ivar.dofIndices().size(), jvar.dofIndicesLower().size() / dofs_divisor);
2952
2953 // derivatives w.r.t. interior primary residuals
2954 jacobianBlockMortar(Moose::PrimaryLower, vi, vj, LocalDataKey{}, tag)
2955 .resize(ivar.dofIndicesNeighbor().size(), jvar.dofIndicesLower().size() / dofs_divisor);
2956
2957 jacobianBlockLowerUsed(tag, vi, vj, false);
2958 }
2959 }
2960
2961 const std::vector<MooseVariableFEBase *> & vars = _sys.getVariables(_tid);
2962 for (const auto & var : vars)
2963 for (auto & tag_Rl : _sub_Rl)
2964 tag_Rl[var->number()].resize(var->dofIndicesLower().size());
2965}
virtual const std::vector< dof_id_type > & dofIndicesLower() const =0
Get dof indices for the current lower dimensional element (this is meaningful when performing mortar ...
virtual const std::vector< dof_id_type > & dofIndicesNeighbor() const =0
Get neighbor DOF indices for currently selected element.

Referenced by SubProblem::reinitLowerDElem().

◆ prepareNeighbor()

void Assembly::prepareNeighbor ( )

Definition at line 2878 of file Assembly.C.

2879{
2880 for (const auto & it : _cm_ff_entry)
2881 {
2882 MooseVariableFEBase & ivar = *(it.first);
2883 MooseVariableFEBase & jvar = *(it.second);
2884
2885 unsigned int vi = ivar.number();
2886 unsigned int vj = jvar.number();
2887
2888 const bool array_block_diagonal_purely_diagonal = vi == vj && _component_block_diagonal[vi];
2889 const auto dofs_divisor = array_block_diagonal_purely_diagonal ? jvar.count() : 1;
2890
2891 for (MooseIndex(_jacobian_block_neighbor_used) tag = 0;
2892 tag < _jacobian_block_neighbor_used.size();
2893 tag++)
2894 {
2895 jacobianBlockNeighbor(Moose::ElementNeighbor, vi, vj, LocalDataKey{}, tag)
2896 .resize(ivar.dofIndices().size(), jvar.dofIndicesNeighbor().size() / dofs_divisor);
2897
2898 jacobianBlockNeighbor(Moose::NeighborElement, vi, vj, LocalDataKey{}, tag)
2899 .resize(ivar.dofIndicesNeighbor().size(), jvar.dofIndices().size() / dofs_divisor);
2900
2901 jacobianBlockNeighbor(Moose::NeighborNeighbor, vi, vj, LocalDataKey{}, tag)
2902 .resize(ivar.dofIndicesNeighbor().size(),
2903 jvar.dofIndicesNeighbor().size() / dofs_divisor);
2904
2905 jacobianBlockNeighborUsed(tag, vi, vj, false);
2906 }
2907 }
2908
2909 const std::vector<MooseVariableFEBase *> & vars = _sys.getVariables(_tid);
2910 for (const auto & var : vars)
2911 for (auto & tag_Rn : _sub_Rn)
2912 tag_Rn[var->number()].resize(var->dofIndicesNeighbor().size());
2913}

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

◆ prepareNonlocal()

void Assembly::prepareNonlocal ( )

Definition at line 2792 of file Assembly.C.

2793{
2794 for (const auto & it : _cm_nonlocal_entry)
2795 {
2796 MooseVariableFEBase & ivar = *(it.first);
2797 MooseVariableFEBase & jvar = *(it.second);
2798
2799 unsigned int vi = ivar.number();
2800 unsigned int vj = jvar.number();
2801
2802 const bool array_block_diagonal_purely_diagonal = vi == vj && _component_block_diagonal[vi];
2803 auto num_cols = jvar.allDofIndices().size();
2804 if (array_block_diagonal_purely_diagonal)
2805 num_cols /= jvar.count();
2806
2807 for (MooseIndex(_jacobian_block_nonlocal_used) tag = 0;
2808 tag < _jacobian_block_nonlocal_used.size();
2809 tag++)
2810 {
2811 jacobianBlockNonlocal(vi, vj, LocalDataKey{}, tag).resize(ivar.dofIndices().size(), num_cols);
2812 jacobianBlockNonlocalUsed(tag, vi, vj, false);
2813 }
2814 }
2815}
const std::vector< dof_id_type > & allDofIndices() const
Get all global dofindices for the variable.

◆ prepareOffDiagScalar()

void Assembly::prepareOffDiagScalar ( )

Definition at line 3043 of file Assembly.C.

3044{
3045 const std::vector<MooseVariableFEBase *> & vars = _sys.getVariables(_tid);
3046 const std::vector<MooseVariableScalar *> & scalar_vars = _sys.getScalarVariables(_tid);
3047
3048 for (const auto & ivar : scalar_vars)
3049 {
3050 auto idofs = ivar->dofIndices().size();
3051
3052 for (const auto & jvar : vars)
3053 {
3054 auto jdofs = jvar->dofIndices().size() * jvar->count();
3055 for (MooseIndex(_jacobian_block_used) tag = 0; tag < _jacobian_block_used.size(); tag++)
3056 {
3057 jacobianBlock(ivar->number(), jvar->number(), LocalDataKey{}, tag).resize(idofs, jdofs);
3058 jacobianBlockUsed(tag, ivar->number(), jvar->number(), false);
3059
3060 jacobianBlock(jvar->number(), ivar->number(), LocalDataKey{}, tag).resize(jdofs, idofs);
3061 jacobianBlockUsed(tag, jvar->number(), ivar->number(), false);
3062 }
3063 }
3064 }
3065}

Referenced by NodalScalarKernel::reinit().

◆ preparePRefinement()

void Assembly::preparePRefinement ( )

Prepare helper FEs for p-refinement.

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

Definition at line 4902 of file Assembly.C.

4903{
4905 // Already performed tasks for p-refinement
4906 return;
4907
4908 const auto helper_type = _helper_type;
4909 auto process_fe_and_helpers = [&helper_type](auto & unique_helper_container,
4910 auto & helper_container,
4911 const unsigned int num_dimensionalities,
4912 const bool user_added_helper_type,
4913 auto & fe_container)
4914 {
4915 unique_helper_container.resize(num_dimensionalities);
4916 for (const auto dim : make_range(num_dimensionalities))
4917 {
4918 auto & unique_helper = unique_helper_container[dim];
4919 unique_helper = FEGenericBase<Real>::build(dim, helper_type);
4920 // don't participate in p-refinement
4921 unique_helper->add_p_level_in_reinit(false);
4922 helper_container[dim] = unique_helper.get();
4923
4924 // If the user did not request the helper type then we should erase the original helper FE
4925 // from the ordinary FE container. The unique helper above replaces it for helper use.
4926 if (!user_added_helper_type)
4927 {
4928 auto & fe_container_dim = libmesh_map_find(fe_container, dim);
4929 auto fe_it = fe_container_dim.find(helper_type);
4930 mooseAssert(fe_it != fe_container_dim.end(), "We should have the helper type");
4931 delete fe_it->second;
4932 fe_container_dim.erase(fe_it);
4933 }
4934 }
4935 };
4936
4937 // Handle scalar field families
4938 process_fe_and_helpers(_unique_fe_helper,
4940 _mesh_dimension + 1,
4942 _fe);
4943 process_fe_and_helpers(_unique_fe_face_helper,
4945 _mesh_dimension + 1,
4947 _fe_face);
4948 process_fe_and_helpers(_unique_fe_face_neighbor_helper,
4950 _mesh_dimension + 1,
4953 process_fe_and_helpers(_unique_fe_neighbor_helper,
4955 _mesh_dimension + 1,
4957 _fe_neighbor);
4958 process_fe_and_helpers(_unique_fe_lower_helper,
4962 _fe_lower);
4963
4965
4967}
std::vector< std::unique_ptr< FEBase > > _unique_fe_lower_helper
Definition Assembly.h:2372
std::vector< std::unique_ptr< FEBase > > _unique_fe_face_neighbor_helper
Definition Assembly.h:2370
std::vector< std::unique_ptr< FEBase > > _unique_fe_face_helper
Definition Assembly.h:2369
std::vector< std::unique_ptr< FEBase > > _unique_fe_helper
Containers for holding unique FE helper types if we are doing p-refinement.
Definition Assembly.h:2368
std::vector< std::unique_ptr< FEBase > > _unique_fe_neighbor_helper
Definition Assembly.h:2371

Referenced by SubProblem::preparePRefinement().

◆ prepareResidual()

void Assembly::prepareResidual ( )

Sizes and zeroes the residual for the current element.

Definition at line 2776 of file Assembly.C.

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

Referenced by prepare(), and reinitFVFace().

◆ prepareScalar()

void Assembly::prepareScalar ( )

Definition at line 3019 of file Assembly.C.

3020{
3021 const std::vector<MooseVariableScalar *> & vars = _sys.getScalarVariables(_tid);
3022 for (const auto & ivar : vars)
3023 {
3024 auto idofs = ivar->dofIndices().size();
3025
3026 for (auto & tag_Re : _sub_Re)
3027 tag_Re[ivar->number()].resize(idofs);
3028
3029 for (const auto & jvar : vars)
3030 {
3031 auto jdofs = jvar->dofIndices().size();
3032
3033 for (MooseIndex(_jacobian_block_used) tag = 0; tag < _jacobian_block_used.size(); tag++)
3034 {
3035 jacobianBlock(ivar->number(), jvar->number(), LocalDataKey{}, tag).resize(idofs, jdofs);
3036 jacobianBlockUsed(tag, ivar->number(), jvar->number(), false);
3037 }
3038 }
3039 }
3040}

Referenced by FEProblemBase::reinitScalars().

◆ prepareVariable()

void Assembly::prepareVariable ( MooseVariableFieldBase *  var)

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

Parameters
varThe variable that needs to have its datastructures prepared

Definition at line 2818 of file Assembly.C.

2819{
2820 for (const auto & it : _cm_ff_entry)
2821 {
2822 MooseVariableFEBase & ivar = *(it.first);
2823 MooseVariableFEBase & jvar = *(it.second);
2824
2825 unsigned int vi = ivar.number();
2826 unsigned int vj = jvar.number();
2827
2828 const bool array_block_diagonal_purely_diagonal = vi == vj && _component_block_diagonal[vi];
2829 auto num_cols = jvar.dofIndices().size();
2830 if (array_block_diagonal_purely_diagonal)
2831 num_cols /= jvar.count();
2832
2833 if (vi == var->number() || vj == var->number())
2834 {
2835 for (MooseIndex(_jacobian_block_used) tag = 0; tag < _jacobian_block_used.size(); tag++)
2836 {
2837 jacobianBlock(vi, vj, LocalDataKey{}, tag).resize(ivar.dofIndices().size(), num_cols);
2838 jacobianBlockUsed(tag, vi, vj, false);
2839 }
2840 }
2841 }
2842
2843 for (auto & tag_Re : _sub_Re)
2844 tag_Re[var->number()].resize(var->dofIndices().size());
2845}

◆ prepareVariableNonlocal()

void Assembly::prepareVariableNonlocal ( MooseVariableFieldBase *  var)

Definition at line 2848 of file Assembly.C.

2849{
2850 for (const auto & it : _cm_nonlocal_entry)
2851 {
2852 MooseVariableFEBase & ivar = *(it.first);
2853 MooseVariableFEBase & jvar = *(it.second);
2854
2855 unsigned int vi = ivar.number();
2856 unsigned int vj = jvar.number();
2857
2858 const bool array_block_diagonal_purely_diagonal = vi == vj && _component_block_diagonal[vi];
2859 auto num_cols = jvar.dofIndices().size();
2860 if (array_block_diagonal_purely_diagonal)
2861 num_cols /= jvar.count();
2862
2863 if (vi == var->number() || vj == var->number())
2864 {
2865 for (MooseIndex(_jacobian_block_nonlocal_used) tag = 0;
2866 tag < _jacobian_block_nonlocal_used.size();
2867 tag++)
2868 {
2869 jacobianBlockNonlocal(vi, vj, LocalDataKey{}, tag)
2870 .resize(ivar.dofIndices().size(), num_cols);
2871 jacobianBlockNonlocalUsed(tag, vi, vj);
2872 }
2873 }
2874 }
2875}

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

3290{
3291 mooseAssert(res_block.size() == dof_indices.size(),
3292 "The size of residual and degree of freedom container must be the same");
3293
3294 // For an array variable, ndof is the number of dofs of the zero-th component and
3295 // ntdof is the number of dofs of all components.
3296 // For standard or vector variables, ndof will be the same as ntdof.
3297 const auto ntdof = res_block.size();
3298 const auto count = scaling_factor.size();
3299 const auto ndof = ntdof / count;
3300 if (count > 1)
3301 {
3302 unsigned int p = 0;
3303 for (MooseIndex(count) j = 0; j < count; ++j)
3304 for (MooseIndex(ndof) i = 0; i < ndof; ++i)
3305 res_block(p++) *= scaling_factor[j];
3306 }
3307 else
3308 {
3309 if (scaling_factor[0] != 1.0)
3310 res_block *= scaling_factor[0];
3311 }
3312
3313 _dof_map.constrain_element_vector(res_block, dof_indices, false);
3314}
unsigned int count
Definition MortarUtils.C:53

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

◆ qPoints()

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

Returns the reference to the quadrature points.

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

Definition at line 250 of file Assembly.h.

250{ 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 335 of file Assembly.h.

335{ return _current_q_points_face; }

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

◆ qPointsFaceNeighbor()

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

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

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

Definition at line 535 of file Assembly.h.

MooseArray< Point > _current_q_points_face_neighbor
The current quadrature points on the neighbor face.
Definition Assembly.h:2564

◆ qPointsMortar()

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

Returns the reference to the mortar segment element quadrature points.

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

Definition at line 256 of file Assembly.h.

256{ return _fe_msm->get_xyz(); }

◆ qRule()

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

Returns the reference to the current quadrature being used.

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

Definition at line 227 of file Assembly.h.

227{ return constify_ref(_current_qrule); }

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

◆ qruleArbitraryFace()

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

Definition at line 1968 of file Assembly.C.

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

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

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

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

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

2471 {
2472 auto dim = elem->dim();
2473 auto neighbor = elem->neighbor_ptr(side);
2474 auto q = rule_fn(qrules(dim, elem->subdomain_id()));
2475 if (!neighbor)
2476 return q;
2477
2478 // find the maximum face quadrature order for all blocks the face is in
2479 auto neighbor_block = neighbor->subdomain_id();
2480 if (neighbor_block == elem->subdomain_id())
2481 return q;
2482
2483 auto q_neighbor = rule_fn(qrules(dim, neighbor_block));
2484 if (q->get_order() > q_neighbor->get_order())
2485 return q;
2486 return q_neighbor;
2487 }
const Elem *const & neighbor() const
Return the neighbor element.
Definition Assembly.h:466

◆ qRuleMortar()

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

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

Definition at line 708 of file Assembly.h.

708{ 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 514 of file Assembly.h.

515 {
517 }

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

◆ qrules() [1/2]

QRules & Assembly::qrules ( unsigned int  dim)
inlineprivate

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

2495 {
2496 if (_qrules.find(block) == _qrules.end())
2497 {
2498 mooseAssert(_qrules.find(Moose::ANY_BLOCK_ID) != _qrules.end(),
2499 "missing quadrature rules for specified block");
2500 mooseAssert(_qrules[Moose::ANY_BLOCK_ID].size() > dim,
2501 "quadrature rules not sized property for dimension");
2503 }
2504 mooseAssert(_qrules.find(block) != _qrules.end(),
2505 "missing quadrature rules for specified block");
2506 mooseAssert(_qrules[block].size() > dim, "quadrature rules not sized property for dimension");
2507 return _qrules[block][dim];
2508 }

◆ reinit() [1/5]

void Assembly::reinit ( const Elem *  elem)

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

Parameters
elemThe element we want to reinitialize on

Definition at line 1864 of file Assembly.C.

1865{
1867 _current_neighbor_elem = nullptr;
1868 mooseAssert(_current_subdomain_id == _current_elem->subdomain_id(),
1869 "current subdomain has been set incorrectly");
1872 reinitFE(elem);
1873
1875}
void reinitFE(const Elem *elem)
Just an internal helper function to reinit the volume FE objects.
Definition Assembly.C:797
void setVolumeQRule(libMesh::QBase *qrule, unsigned int dim)
Set the qrule to be used for volume integration.
void computeCurrentElemVolume()
Definition Assembly.C:1799

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

1879{
1881 _current_neighbor_elem = nullptr;
1882 mooseAssert(_current_subdomain_id == _current_elem->subdomain_id(),
1883 "current subdomain has been set incorrectly");
1885
1886 unsigned int elem_dimension = _current_elem->dim();
1887
1888 _current_qrule_arbitrary = qrules(elem_dimension).arbitrary_vol.get();
1889
1890 // Make sure the qrule is the right one
1893
1894 _current_qrule_arbitrary->setPoints(reference_points);
1895
1896 reinitFE(elem);
1897
1899}
void setPoints(const std::vector< libMesh::Point > &points)
Set the quadrature points.
std::unique_ptr< ArbitraryQuadrature > arbitrary_vol
volume/elem (meshdim) custom points quadrature rule
Definition Assembly.h:2447

◆ reinit() [3/5]

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

Reinitialize the assembly data on an side of an element.

Definition at line 1985 of file Assembly.C.

1986{
1988 _current_neighbor_elem = nullptr;
1989 mooseAssert(_current_subdomain_id == _current_elem->subdomain_id(),
1990 "current subdomain has been set incorrectly");
1994
1996
1999
2001}
void computeCurrentFaceVolume()
Definition Assembly.C:1818
void setFaceQRule(libMesh::QBase *qrule, unsigned int dim)
Set the qrule to be used for face integration.
libMesh::ElemSideBuilder _current_side_elem_builder
In place side element builder for _current_side_elem.
Definition Assembly.h:2887
void reinitFEFace(const Elem *elem, unsigned int side)
Just an internal helper function to reinit the face FE objects.
Definition Assembly.C:1313

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

2005{
2007 _current_neighbor_elem = nullptr;
2008 mooseAssert(_current_subdomain_id == _current_elem->subdomain_id(),
2009 "current subdomain has been set incorrectly");
2013
2014 unsigned int elem_dimension = _current_elem->dim();
2015
2017
2018 // Make sure the qrule is the right one
2021
2022 _current_qrule_arbitrary->setPoints(reference_points);
2023
2025
2027
2029}
ArbitraryQuadrature * qruleArbitraryFace(const Elem *elem, unsigned int side)
Definition Assembly.C:1968
ArbitraryQuadrature * _current_qrule_arbitrary_face
The current arbitrary quadrature rule used on the element face.
Definition Assembly.h:2415

◆ reinit() [5/5]

void Assembly::reinit ( const Node *  node)

Reinitialize assembly data for a node.

Definition at line 2032 of file Assembly.C.

2033{
2036}

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

1838{
1840 _current_neighbor_elem = nullptr;
1841 mooseAssert(_current_subdomain_id == _current_elem->subdomain_id(),
1842 "current subdomain has been set incorrectly");
1844
1845 FEMap::inverse_map(elem->dim(), elem, physical_points, _temp_reference_points);
1846
1848
1849 // Save off the physical points
1850 _current_physical_points = physical_points;
1851}
std::vector< Point > _temp_reference_points
Temporary work data for reinitAtPhysical()
Definition Assembly.h:2837
void reinit(const Elem *elem)
Reinitialize objects (JxW, q_points, ...) for an elements.
Definition Assembly.C:1864

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

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

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
elemElement being reinitialized
sideSide of the element
neighborNeighbor facing the element on the side 'side'
neighbor_sideThe side id on the neighboring element.
neighbor_reference_pointsOptional 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 2039 of file Assembly.C.

2044{
2045 _current_neighbor_side = neighbor_side;
2046
2047 reinit(elem, side);
2048
2049 unsigned int neighbor_dim = neighbor->dim();
2050
2051 if (neighbor_reference_points)
2052 _current_neighbor_ref_points = *neighbor_reference_points;
2053 else
2054 FEMap::inverse_map(
2056
2058
2061}
void reinitFEFaceNeighbor(const Elem *neighbor, const std::vector< Point > &reference_points)
Definition Assembly.C:1618
libMesh::ElemSideBuilder _current_neighbor_side_elem_builder
In place side element builder for _current_neighbor_side_elem.
Definition Assembly.h:2889
void reinitNeighbor(const Elem *neighbor, const std::vector< Point > &reference_points)
Reinitializes the neighbor side using reference coordinates.
Definition Assembly.C:1732
std::vector< Point > _current_neighbor_ref_points
The current reference points on the neighbor element.
Definition Assembly.h:2914
std::vector< T > stdVector() const
Extremely inefficient way to produce a std::vector from a MooseArray!
Definition MooseArray.h:344

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

2069{
2071
2072 unsigned int elem_dim = elem->dim();
2073
2074 // Attach the quadrature rules
2075 if (pts)
2076 {
2077 auto face_rule = qruleArbitraryFace(elem, elem_side);
2078 face_rule->setPoints(*pts);
2079 setFaceQRule(face_rule, elem_dim);
2080 }
2081 else
2082 {
2083 auto rule = qruleFace(elem, elem_side);
2084 if (_current_qrule_face != rule)
2085 setFaceQRule(rule, elem_dim);
2086 }
2087
2088 // reinit face
2089 for (const auto & it : _fe_face[elem_dim])
2090 {
2091 FEBase & fe_face = *it.second;
2092 FEType fe_type = it.first;
2093 FEShapeData & fesd = *_fe_shape_data_face[fe_type];
2094
2095 fe_face.reinit(elem, elem_side, tolerance, pts, weights);
2096
2097 _current_fe_face[fe_type] = &fe_face;
2098
2099 fesd._phi.shallowCopy(const_cast<std::vector<std::vector<Real>> &>(fe_face.get_phi()));
2100 fesd._grad_phi.shallowCopy(
2101 const_cast<std::vector<std::vector<RealGradient>> &>(fe_face.get_dphi()));
2102 if (_need_second_derivative_neighbor.count(fe_type))
2103 fesd._second_phi.shallowCopy(
2104 const_cast<std::vector<std::vector<TensorValue<Real>>> &>(fe_face.get_d2phi()));
2105 }
2106 for (const auto & it : _vector_fe_face[elem_dim])
2107 {
2108 FEVectorBase & fe_face = *it.second;
2109 const FEType & fe_type = it.first;
2110
2111 _current_vector_fe_face[fe_type] = &fe_face;
2112
2113 VectorFEShapeData & fesd = *_vector_fe_shape_data_face[fe_type];
2114
2115 fe_face.reinit(elem, elem_side, tolerance, pts, weights);
2116
2117 fesd._phi.shallowCopy(
2118 const_cast<std::vector<std::vector<VectorValue<Real>>> &>(fe_face.get_phi()));
2119 fesd._grad_phi.shallowCopy(
2120 const_cast<std::vector<std::vector<TensorValue<Real>>> &>(fe_face.get_dphi()));
2121 if (_need_second_derivative.count(fe_type))
2122 fesd._second_phi.shallowCopy(
2123 const_cast<std::vector<std::vector<TypeNTensor<3, Real>>> &>(fe_face.get_d2phi()));
2124 if (_need_curl.count(fe_type))
2125 fesd._curl_phi.shallowCopy(
2126 const_cast<std::vector<std::vector<VectorValue<Real>>> &>(fe_face.get_curl_phi()));
2127 if (_need_face_div.count(fe_type))
2128 fesd._div_phi.shallowCopy(
2129 const_cast<std::vector<std::vector<Real>> &>(fe_face.get_div_phi()));
2130 }
2131 if (!_unique_fe_face_helper.empty())
2132 {
2133 mooseAssert(elem_dim < _unique_fe_face_helper.size(), "We should be in bounds here");
2134 _unique_fe_face_helper[elem_dim]->reinit(elem, elem_side, tolerance, pts, weights);
2135 }
2136
2137 // During that last loop the helper objects will have been reinitialized
2139 const_cast<std::vector<Point> &>(_holder_fe_face_helper[elem_dim]->get_xyz()));
2141 const_cast<std::vector<Point> &>(_holder_fe_face_helper[elem_dim]->get_normals()));
2142 _current_tangents.shallowCopy(const_cast<std::vector<std::vector<Point>> &>(
2143 _holder_fe_face_helper[elem_dim]->get_tangents()));
2144 // Note that if the user did pass in points and not weights to this method, JxW will be garbage
2145 // and should not be used
2147 const_cast<std::vector<Real> &>(_holder_fe_face_helper[elem_dim]->get_JxW()));
2150 const_cast<std::vector<Real> &>(_holder_fe_face_helper[elem_dim]->get_curvatures()));
2151
2152 computeADFace(*elem, elem_side);
2153
2154 // Keep the current-side bookkeeping consistent with the other elem/side reinit overloads so
2155 // that consumers of _current_side, _current_side_elem, and _current_side_volume (e.g.
2156 // InterfaceKernelBase) see correct values rather than whatever was left over from a previous
2157 // reinit.
2158 _current_side = elem_side;
2162}
MooseArray< std::vector< Point > > _current_tangents
The current tangent vectors at the quadrature points.
Definition Assembly.h:2533
void computeADFace(const Elem &elem, const unsigned int side)
compute AD things on an element face
Definition Assembly.C:2165
libMesh::QBase * qruleFace(const Elem *elem, unsigned int side)
This is an abstraction over the internal qrules function.
Definition Assembly.C:1962
std::map< FEType, FEBase * > _current_fe_face
The "face" fe object that matches the current elem.
Definition Assembly.h:2383
std::map< FEType, FEVectorBase * > _current_vector_fe_face
The "face" vector fe object that matches the current elem.
Definition Assembly.h:2392
void shallowCopy(const MooseArray &rhs)
Doesn't actually make a copy of the data.
Definition MooseArray.h:296

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

◆ reinitFE()

void Assembly::reinitFE ( const Elem *  elem)
private

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

Parameters
elemThe element we are using to reinit

Definition at line 797 of file Assembly.C.

798{
799 unsigned int dim = elem->dim();
800
801 for (const auto & it : _fe[dim])
802 {
803 FEBase & fe = *it.second;
804 const FEType & fe_type = it.first;
805
806 _current_fe[fe_type] = &fe;
807
808 FEShapeData & fesd = *_fe_shape_data[fe_type];
809
810 fe.reinit(elem);
811
812 fesd._phi.shallowCopy(const_cast<std::vector<std::vector<Real>> &>(fe.get_phi()));
813 fesd._grad_phi.shallowCopy(
814 const_cast<std::vector<std::vector<VectorValue<Real>>> &>(fe.get_dphi()));
815 if (_need_second_derivative.count(fe_type))
816 fesd._second_phi.shallowCopy(
817 const_cast<std::vector<std::vector<TensorValue<Real>>> &>(fe.get_d2phi()));
818 }
819 for (const auto & it : _vector_fe[dim])
820 {
821 FEVectorBase & fe = *it.second;
822 const FEType & fe_type = it.first;
823
824 _current_vector_fe[fe_type] = &fe;
825
826 VectorFEShapeData & fesd = *_vector_fe_shape_data[fe_type];
827
828 fe.reinit(elem);
829
830 fesd._phi.shallowCopy(const_cast<std::vector<std::vector<VectorValue<Real>>> &>(fe.get_phi()));
831 fesd._grad_phi.shallowCopy(
832 const_cast<std::vector<std::vector<TensorValue<Real>>> &>(fe.get_dphi()));
833 if (_need_second_derivative.count(fe_type))
834 fesd._second_phi.shallowCopy(
835 const_cast<std::vector<std::vector<TypeNTensor<3, Real>>> &>(fe.get_d2phi()));
836 if (_need_curl.count(fe_type))
837 fesd._curl_phi.shallowCopy(
838 const_cast<std::vector<std::vector<VectorValue<Real>>> &>(fe.get_curl_phi()));
839 if (_need_div.count(fe_type))
840 fesd._div_phi.shallowCopy(const_cast<std::vector<std::vector<Real>> &>(fe.get_div_phi()));
841 }
842 if (!_unique_fe_helper.empty())
843 {
844 mooseAssert(dim < _unique_fe_helper.size(), "We should be in bounds here");
845 _unique_fe_helper[dim]->reinit(elem);
846 }
847
848 // During that last loop the helper objects will have been reinitialized as well
849 // We need to dig out the q_points and JxW from it.
851 const_cast<std::vector<Point> &>(_holder_fe_helper[dim]->get_xyz()));
852 _current_JxW.shallowCopy(const_cast<std::vector<Real> &>(_holder_fe_helper[dim]->get_JxW()));
853
854 // The AD map is needed for the AD JxW, quadrature points and coordinate transformation and for
855 // the AD shape function gradients, which use its inverse
857 {
858 auto n_qp = _current_qrule->n_points();
859 resizeADMappingObjects(n_qp, dim);
860 if (_displaced)
861 {
862 const auto & qw = _current_qrule->get_weights();
863 for (unsigned int qp = 0; qp != n_qp; qp++)
865 }
866 else
867 {
868 for (unsigned qp = 0; qp < n_qp; ++qp)
869 _ad_JxW[qp] = _current_JxW[qp];
870 if (_calculate_xyz)
871 for (unsigned qp = 0; qp < n_qp; ++qp)
873 }
874
875 for (const auto & it : _fe[dim])
876 {
878 break;
879 FEBase & fe = *it.second;
880 auto fe_type = it.first;
881 auto num_shapes = FEInterface::n_shape_functions(fe_type, elem);
882 auto & grad_phi = _ad_grad_phi_data[fe_type];
883
884 grad_phi.resize(num_shapes);
885 for (decltype(num_shapes) i = 0; i < num_shapes; ++i)
886 grad_phi[i].resize(n_qp);
887
888 if (_displaced)
889 computeGradPhiAD(elem, n_qp, grad_phi, &fe);
890 else
891 {
892 const auto & regular_grad_phi = _fe_shape_data[fe_type]->_grad_phi;
893 for (decltype(num_shapes) i = 0; i < num_shapes; ++i)
894 for (unsigned qp = 0; qp < n_qp; ++qp)
895 grad_phi[i][qp] = regular_grad_phi[i][qp];
896 }
897 }
898 for (const auto & it : _vector_fe[dim])
899 {
901 break;
902 FEVectorBase & fe = *it.second;
903 auto fe_type = it.first;
904 auto num_shapes = FEInterface::n_shape_functions(fe_type, elem);
905 auto & grad_phi = _ad_vector_grad_phi_data[fe_type];
906
907 grad_phi.resize(num_shapes);
908 for (decltype(num_shapes) i = 0; i < num_shapes; ++i)
909 grad_phi[i].resize(n_qp);
910
911 if (_displaced)
912 computeGradPhiAD(elem, n_qp, grad_phi, &fe);
913 else
914 {
915 const auto & regular_grad_phi = _vector_fe_shape_data[fe_type]->_grad_phi;
916 for (decltype(num_shapes) i = 0; i < num_shapes; ++i)
917 for (unsigned qp = 0; qp < n_qp; ++qp)
918 grad_phi[i][qp] = regular_grad_phi[i][qp];
919 }
920 }
921 }
922
923 auto n = numExtraElemIntegers();
924 for (auto i : make_range(n))
925 _extra_elem_ids[i] = _current_elem->get_extra_integer(i);
926 _extra_elem_ids[n] = _current_elem->subdomain_id();
927
928 if (_xfem != nullptr)
930}
void modifyWeightsDueToXFEM(const Elem *elem)
Update the integration weights for XFEM partial elements.
Definition Assembly.C:4583
std::map< FEType, FEVectorBase * > _current_vector_fe
The "volume" vector fe object that matches the current elem.
Definition Assembly.h:2390
std::map< FEType, FEBase * > _current_fe
The "volume" fe object that matches the current elem.
Definition Assembly.h:2381
unsigned int numExtraElemIntegers() const
Number of extra element integers Assembly tracked.
Definition Assembly.h:363

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
elemThe element we are using to reinit
sideThe side of the element we are reiniting on

Definition at line 1313 of file Assembly.C.

1314{
1315 unsigned int dim = elem->dim();
1316
1317 for (const auto & it : _fe_face[dim])
1318 {
1319 FEBase & fe_face = *it.second;
1320 const FEType & fe_type = it.first;
1321 FEShapeData & fesd = *_fe_shape_data_face[fe_type];
1322 fe_face.reinit(elem, side);
1323 _current_fe_face[fe_type] = &fe_face;
1324
1325 fesd._phi.shallowCopy(const_cast<std::vector<std::vector<Real>> &>(fe_face.get_phi()));
1326 fesd._grad_phi.shallowCopy(
1327 const_cast<std::vector<std::vector<VectorValue<Real>>> &>(fe_face.get_dphi()));
1328 if (_need_second_derivative.count(fe_type))
1329 fesd._second_phi.shallowCopy(
1330 const_cast<std::vector<std::vector<TensorValue<Real>>> &>(fe_face.get_d2phi()));
1331 }
1332 for (const auto & it : _vector_fe_face[dim])
1333 {
1334 FEVectorBase & fe_face = *it.second;
1335 const FEType & fe_type = it.first;
1336
1337 _current_vector_fe_face[fe_type] = &fe_face;
1338
1339 VectorFEShapeData & fesd = *_vector_fe_shape_data_face[fe_type];
1340
1341 fe_face.reinit(elem, side);
1342
1343 fesd._phi.shallowCopy(
1344 const_cast<std::vector<std::vector<VectorValue<Real>>> &>(fe_face.get_phi()));
1345 fesd._grad_phi.shallowCopy(
1346 const_cast<std::vector<std::vector<TensorValue<Real>>> &>(fe_face.get_dphi()));
1347 if (_need_second_derivative.count(fe_type))
1348 fesd._second_phi.shallowCopy(
1349 const_cast<std::vector<std::vector<TypeNTensor<3, Real>>> &>(fe_face.get_d2phi()));
1350 if (_need_curl.count(fe_type))
1351 fesd._curl_phi.shallowCopy(
1352 const_cast<std::vector<std::vector<VectorValue<Real>>> &>(fe_face.get_curl_phi()));
1353 if (_need_face_div.count(fe_type))
1354 fesd._div_phi.shallowCopy(
1355 const_cast<std::vector<std::vector<Real>> &>(fe_face.get_div_phi()));
1356 }
1357 if (!_unique_fe_face_helper.empty())
1358 {
1359 mooseAssert(dim < _unique_fe_face_helper.size(), "We should be in bounds here");
1361 }
1362
1363 // During that last loop the helper objects will have been reinitialized as well
1364 // We need to dig out the q_points and JxW from it.
1366 const_cast<std::vector<Point> &>(_holder_fe_face_helper[dim]->get_xyz()));
1368 const_cast<std::vector<Real> &>(_holder_fe_face_helper[dim]->get_JxW()));
1370 const_cast<std::vector<Point> &>(_holder_fe_face_helper[dim]->get_normals()));
1371
1372 _mapped_normals.resize(_current_normals.size(), Eigen::Map<RealDIMValue>(nullptr));
1373 for (unsigned int i = 0; i < _current_normals.size(); i++)
1374 // Note: this does NOT do any allocation. It is "reconstructing" the object in place
1375 new (&_mapped_normals[i]) Eigen::Map<RealDIMValue>(const_cast<Real *>(&_current_normals[i](0)));
1376
1379 const_cast<std::vector<Real> &>(_holder_fe_face_helper[dim]->get_curvatures()));
1380
1382
1383 if (_xfem != nullptr)
1385
1386 auto n = numExtraElemIntegers();
1387 for (auto i : make_range(n))
1388 _extra_elem_ids[i] = _current_elem->get_extra_integer(i);
1389 _extra_elem_ids[n] = _current_elem->subdomain_id();
1390}
void modifyFaceWeightsDueToXFEM(const Elem *elem, unsigned int side=0)
Update the face integration weights for XFEM partial elements.
Definition Assembly.C:4603

Referenced by reinit(), and reinit().

◆ reinitFEFaceNeighbor()

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

Definition at line 1618 of file Assembly.C.

1619{
1620 unsigned int neighbor_dim = neighbor->dim();
1621
1622 // reinit neighbor face
1623 for (const auto & it : _fe_face_neighbor[neighbor_dim])
1624 {
1625 FEBase & fe_face_neighbor = *it.second;
1626 FEType fe_type = it.first;
1627 FEShapeData & fesd = *_fe_shape_data_face_neighbor[fe_type];
1628
1629 fe_face_neighbor.reinit(neighbor, &reference_points);
1630
1631 _current_fe_face_neighbor[fe_type] = &fe_face_neighbor;
1632
1633 fesd._phi.shallowCopy(const_cast<std::vector<std::vector<Real>> &>(fe_face_neighbor.get_phi()));
1634 fesd._grad_phi.shallowCopy(
1635 const_cast<std::vector<std::vector<RealGradient>> &>(fe_face_neighbor.get_dphi()));
1636 if (_need_second_derivative_neighbor.count(fe_type))
1637 fesd._second_phi.shallowCopy(
1638 const_cast<std::vector<std::vector<TensorValue<Real>>> &>(fe_face_neighbor.get_d2phi()));
1639 }
1640 for (const auto & it : _vector_fe_face_neighbor[neighbor_dim])
1641 {
1642 FEVectorBase & fe_face_neighbor = *it.second;
1643 const FEType & fe_type = it.first;
1644
1645 _current_vector_fe_face_neighbor[fe_type] = &fe_face_neighbor;
1646
1647 VectorFEShapeData & fesd = *_vector_fe_shape_data_face_neighbor[fe_type];
1648
1649 fe_face_neighbor.reinit(neighbor, &reference_points);
1650
1651 fesd._phi.shallowCopy(
1652 const_cast<std::vector<std::vector<VectorValue<Real>>> &>(fe_face_neighbor.get_phi()));
1653 fesd._grad_phi.shallowCopy(
1654 const_cast<std::vector<std::vector<TensorValue<Real>>> &>(fe_face_neighbor.get_dphi()));
1655 if (_need_second_derivative.count(fe_type))
1656 fesd._second_phi.shallowCopy(const_cast<std::vector<std::vector<TypeNTensor<3, Real>>> &>(
1657 fe_face_neighbor.get_d2phi()));
1658 if (_need_curl.count(fe_type))
1659 fesd._curl_phi.shallowCopy(const_cast<std::vector<std::vector<VectorValue<Real>>> &>(
1660 fe_face_neighbor.get_curl_phi()));
1661 if (_need_face_neighbor_div.count(fe_type))
1662 fesd._div_phi.shallowCopy(
1663 const_cast<std::vector<std::vector<Real>> &>(fe_face_neighbor.get_div_phi()));
1664 }
1666 {
1667 mooseAssert(neighbor_dim < _unique_fe_face_neighbor_helper.size(),
1668 "We should be in bounds here");
1669 _unique_fe_face_neighbor_helper[neighbor_dim]->reinit(neighbor, &reference_points);
1670 }
1671
1673 const_cast<std::vector<Point> &>(_holder_fe_face_neighbor_helper[neighbor_dim]->get_xyz()));
1674}
std::map< FEType, FEVectorBase * > _current_vector_fe_face_neighbor
The "neighbor face" vector fe object that matches the current elem.
Definition Assembly.h:2396
std::map< FEType, FEBase * > _current_fe_face_neighbor
The "neighbor face" fe object that matches the current elem.
Definition Assembly.h:2387

Referenced by reinitElemAndNeighbor(), and reinitNeighborAtPhysical().

◆ reinitFENeighbor()

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

Definition at line 1677 of file Assembly.C.

1678{
1679 unsigned int neighbor_dim = neighbor->dim();
1680
1681 // reinit neighbor face
1682 for (const auto & it : _fe_neighbor[neighbor_dim])
1683 {
1684 FEBase & fe_neighbor = *it.second;
1685 FEType fe_type = it.first;
1686 FEShapeData & fesd = *_fe_shape_data_neighbor[fe_type];
1687
1688 fe_neighbor.reinit(neighbor, &reference_points);
1689
1690 _current_fe_neighbor[fe_type] = &fe_neighbor;
1691
1692 fesd._phi.shallowCopy(const_cast<std::vector<std::vector<Real>> &>(fe_neighbor.get_phi()));
1693 fesd._grad_phi.shallowCopy(
1694 const_cast<std::vector<std::vector<RealGradient>> &>(fe_neighbor.get_dphi()));
1695 if (_need_second_derivative_neighbor.count(fe_type))
1696 fesd._second_phi.shallowCopy(
1697 const_cast<std::vector<std::vector<TensorValue<Real>>> &>(fe_neighbor.get_d2phi()));
1698 }
1699 for (const auto & it : _vector_fe_neighbor[neighbor_dim])
1700 {
1701 FEVectorBase & fe_neighbor = *it.second;
1702 const FEType & fe_type = it.first;
1703
1704 _current_vector_fe_neighbor[fe_type] = &fe_neighbor;
1705
1706 VectorFEShapeData & fesd = *_vector_fe_shape_data_neighbor[fe_type];
1707
1708 fe_neighbor.reinit(neighbor, &reference_points);
1709
1710 fesd._phi.shallowCopy(
1711 const_cast<std::vector<std::vector<VectorValue<Real>>> &>(fe_neighbor.get_phi()));
1712 fesd._grad_phi.shallowCopy(
1713 const_cast<std::vector<std::vector<TensorValue<Real>>> &>(fe_neighbor.get_dphi()));
1714 if (_need_second_derivative.count(fe_type))
1715 fesd._second_phi.shallowCopy(
1716 const_cast<std::vector<std::vector<TypeNTensor<3, Real>>> &>(fe_neighbor.get_d2phi()));
1717 if (_need_curl.count(fe_type))
1718 fesd._curl_phi.shallowCopy(
1719 const_cast<std::vector<std::vector<VectorValue<Real>>> &>(fe_neighbor.get_curl_phi()));
1720 if (_need_neighbor_div.count(fe_type))
1721 fesd._div_phi.shallowCopy(
1722 const_cast<std::vector<std::vector<Real>> &>(fe_neighbor.get_div_phi()));
1723 }
1724 if (!_unique_fe_neighbor_helper.empty())
1725 {
1726 mooseAssert(neighbor_dim < _unique_fe_neighbor_helper.size(), "We should be in bounds here");
1727 _unique_fe_neighbor_helper[neighbor_dim]->reinit(neighbor, &reference_points);
1728 }
1729}
std::map< FEType, FEBase * > _current_fe_neighbor
The "neighbor" fe object that matches the current elem.
Definition Assembly.h:2385
std::map< FEType, FEVectorBase * > _current_vector_fe_neighbor
The "neighbor" vector fe object that matches the current elem.
Definition Assembly.h:2394

Referenced by reinitNeighborAtPhysical().

◆ reinitFVFace()

void Assembly::reinitFVFace ( const FaceInfo &  fi)

Definition at line 1902 of file Assembly.C.

1903{
1904 _current_elem = &fi.elem();
1908 mooseAssert(_current_subdomain_id == _current_elem->subdomain_id(),
1909 "current subdomain has been set incorrectly");
1910
1913
1917
1918 unsigned int dim = _current_elem->dim();
1919 if (_current_qrule_face != qrules(dim).fv_face.get())
1920 {
1921 setFaceQRule(qrules(dim).fv_face.get(), dim);
1922 // The order of the element that is used for initing here doesn't matter since this will just
1923 // be used for constant monomials (which only need a single integration point)
1924 if (dim == 3)
1925 _current_qrule_face->init(QUAD4, /* p_level = */ 0, /* simple_type_only = */ true);
1926 else
1927 _current_qrule_face->init(EDGE2, /* p_level = */ 0, /* simple_type_only = */ true);
1928 }
1929
1931
1932 mooseAssert(_current_qrule_face->n_points() == 1,
1933 "Our finite volume quadrature rule should always yield a single point");
1934
1935 // We've initialized the reference points. Now we need to compute the physical location of the
1936 // quadrature points. We do not do any FE initialization so we cannot simply copy over FE
1937 // results like we do in reinitFEFace. Instead we handle the computation of the physical
1938 // locations manually
1940 const auto & ref_points = _current_qrule_face->get_points();
1941 const auto & ref_point = ref_points[0];
1942 auto physical_point = FEMap::map(_current_side_elem->dim(), _current_side_elem, ref_point);
1943 _current_q_points_face[0] = physical_point;
1944
1946 {
1947 mooseAssert(_current_neighbor_subdomain_id == _current_neighbor_elem->subdomain_id(),
1948 "current neighbor subdomain has been set incorrectly");
1949 // Now handle the neighbor qrule/qpoints
1950 ArbitraryQuadrature * const neighbor_rule =
1952 // Here we are setting a reference point that is correct for the neighbor *side* element. It
1953 // would be wrong if this reference point is used for a volumetric FE reinit with the neighbor
1954 neighbor_rule->setPoints(ref_points);
1955 setNeighborQRule(neighbor_rule, _current_neighbor_elem->dim());
1957 _current_q_points_face_neighbor[0] = std::move(physical_point);
1958 }
1959}
Implements a fake quadrature rule where you can specify the locations (in the reference domain) of th...
void prepareNeighbor()
Definition Assembly.C:2878
void setNeighborQRule(libMesh::QBase *qrule, unsigned int dim)
Set the qrule to be used for neighbor integration.
Definition Assembly.C:746
unsigned int neighborSideID() const
Definition FaceInfo.h:114
const Elem & elem() const
Definition FaceInfo.h:85
const Elem * neighborPtr() const
Definition FaceInfo.h:88
unsigned int elemSideID() const
Definition FaceInfo.h:113
const std::vector< Point > & get_points() const
virtual void init(const Elem &e, unsigned int p_level=invalid_uint)
std::unique_ptr< ArbitraryQuadrature > neighbor
area/face (meshdim-1) custom points quadrature rule for DG
Definition Assembly.h:2451

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

2361{
2363
2364 const unsigned int elem_dim = elem->dim();
2365 mooseAssert(elem_dim < _mesh_dimension,
2366 "The lower dimensional element should truly be a lower dimensional element");
2367
2368 if (pts)
2369 {
2370 // Lower rule matches the face rule for the higher dimensional element
2371 ArbitraryQuadrature * lower_rule = qrules(elem_dim + 1).arbitrary_face.get();
2372
2373 // This also sets the quadrature weights to unity
2374 lower_rule->setPoints(*pts);
2375
2376 if (weights)
2377 lower_rule->setWeights(*weights);
2378
2379 setLowerQRule(lower_rule, elem_dim);
2380 }
2381 else if (_current_qrule_lower != qrules(elem_dim + 1).face.get())
2382 setLowerQRule(qrules(elem_dim + 1).face.get(), elem_dim);
2383
2384 for (const auto & it : _fe_lower[elem_dim])
2385 {
2386 FEBase & fe_lower = *it.second;
2387 FEType fe_type = it.first;
2388
2389 fe_lower.reinit(elem);
2390
2391 if (FEShapeData * fesd = _fe_shape_data_lower[fe_type].get())
2392 {
2393 fesd->_phi.shallowCopy(const_cast<std::vector<std::vector<Real>> &>(fe_lower.get_phi()));
2394 fesd->_grad_phi.shallowCopy(
2395 const_cast<std::vector<std::vector<RealGradient>> &>(fe_lower.get_dphi()));
2396 if (_need_second_derivative_neighbor.count(fe_type))
2397 fesd->_second_phi.shallowCopy(
2398 const_cast<std::vector<std::vector<TensorValue<Real>>> &>(fe_lower.get_d2phi()));
2399 }
2400
2401 // Dual shape functions need to be computed after primal basis being initialized
2402 if (FEShapeData * fesd = _fe_shape_data_dual_lower[fe_type].get())
2403 {
2404 fesd->_phi.shallowCopy(const_cast<std::vector<std::vector<Real>> &>(fe_lower.get_dual_phi()));
2405 fesd->_grad_phi.shallowCopy(
2406 const_cast<std::vector<std::vector<RealGradient>> &>(fe_lower.get_dual_dphi()));
2407 if (_need_second_derivative_neighbor.count(fe_type))
2408 fesd->_second_phi.shallowCopy(
2409 const_cast<std::vector<std::vector<TensorValue<Real>>> &>(fe_lower.get_dual_d2phi()));
2410 }
2411 }
2412 if (!_unique_fe_lower_helper.empty())
2413 {
2414 mooseAssert(elem_dim < _unique_fe_lower_helper.size(), "We should be in bounds here");
2415 _unique_fe_lower_helper[elem_dim]->reinit(elem);
2416 }
2417
2419 return;
2420
2421 if (pts && !weights)
2422 {
2423 // We only have dummy weights so the JxWs computed during our FE reinits are meaningless and
2424 // we cannot use them
2425
2427 // We are in a Cartesian coordinate system and we can just use the element volume method
2428 // which has fast computation for certain element types
2430 else
2431 // We manually compute the volume taking the curvilinear coordinate transformations into
2432 // account
2434 }
2435 else
2436 {
2437 // During that last loop the helper objects will have been reinitialized as well
2438 FEBase & helper_fe = *_holder_fe_lower_helper[elem_dim];
2439 const auto & physical_q_points = helper_fe.get_xyz();
2440 const auto & JxW = helper_fe.get_JxW();
2441 MooseArray<Real> coord;
2443 _current_qrule_lower, physical_q_points, coord, elem->subdomain_id());
2445 for (const auto qp : make_range(_current_qrule_lower->n_points()))
2446 _current_lower_d_elem_volume += JxW[qp] * coord[qp];
2447 }
2448}
void setWeights(const std::vector< libMesh::Real > &weights)
Set the quadrature weights.
void setLowerQRule(libMesh::QBase *qrule, unsigned int dim)
Set the qrule to be used for lower dimensional integration.
Definition Assembly.C:727
Real elementVolume(const Elem *elem) const
On-demand computation of volume element accounting for RZ/RSpherical.
Definition Assembly.C:3823
Moose::CoordinateSystemType getCoordSystem(SubdomainID sid) const
const Elem & get(const ElemType type_in)
std::unique_ptr< ArbitraryQuadrature > arbitrary_face
area/face (meshdim-1) custom points quadrature rule
Definition Assembly.h:2449

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

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

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

1733{
1734 unsigned int neighbor_dim = neighbor->dim();
1735 mooseAssert(_current_neighbor_subdomain_id == neighbor->subdomain_id(),
1736 "Neighbor subdomain ID has not been correctly set");
1737
1738 ArbitraryQuadrature * neighbor_rule =
1739 qrules(neighbor_dim, _current_neighbor_subdomain_id).neighbor.get();
1740 neighbor_rule->setPoints(reference_points);
1741 setNeighborQRule(neighbor_rule, neighbor_dim);
1742
1744 mooseAssert(_current_neighbor_subdomain_id == _current_neighbor_elem->subdomain_id(),
1745 "current neighbor subdomain has been set incorrectly");
1746
1747 // Calculate the volume of the neighbor
1749 {
1750 unsigned int dim = neighbor->dim();
1752 QBase * qrule = qrules(dim).vol.get();
1753
1754 fe.attach_quadrature_rule(qrule);
1755 fe.reinit(neighbor);
1756
1757 const std::vector<Real> & JxW = fe.get_JxW();
1758 MooseArray<Point> q_points;
1759 q_points.shallowCopy(const_cast<std::vector<Point> &>(fe.get_xyz()));
1760
1762
1764 for (unsigned int qp = 0; qp < qrule->n_points(); qp++)
1766 }
1767
1768 auto n = numExtraElemIntegers();
1769 for (auto i : make_range(n))
1770 _neighbor_extra_elem_ids[i] = _current_neighbor_elem->get_extra_integer(i);
1772}

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

2524{
2525 unsigned int neighbor_dim = neighbor->dim();
2526 FEMap::inverse_map(neighbor_dim, neighbor, physical_points, _current_neighbor_ref_points);
2527
2530 // Save off the physical points
2531 _current_physical_points = physical_points;
2532}
void reinitFENeighbor(const Elem *neighbor, const std::vector< Point > &reference_points)
Definition Assembly.C:1677

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

2489{
2490 unsigned int neighbor_dim = neighbor->dim();
2491 FEMap::inverse_map(neighbor_dim, neighbor, physical_points, _current_neighbor_ref_points);
2492
2494 {
2495 mooseAssert(
2496 physical_points.size() == 1,
2497 "If reinitializing with more than one point, then I am dubious of your use case. Perhaps "
2498 "you are performing a DG type method and you are reinitializing using points from the "
2499 "element face. In such a case your neighbor JxW must have its index order 'match' the "
2500 "element JxW index order, e.g. imagining a vertical 1D face with two quadrature points, "
2501 "if "
2502 "index 0 for elem JxW corresponds to the 'top' quadrature point, then index 0 for "
2503 "neighbor "
2504 "JxW must also correspond to the 'top' quadrature point. And libMesh/MOOSE has no way to "
2505 "guarantee that with multiple quadrature points.");
2506
2508
2509 // With a single point our size-1 JxW should just be the element volume
2512 }
2513
2516
2517 // Save off the physical points
2518 _current_physical_points = physical_points;
2519}

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

2264{
2266
2267 unsigned int neighbor_dim = neighbor->dim();
2268
2269 ArbitraryQuadrature * neighbor_rule =
2270 qrules(neighbor_dim, neighbor->subdomain_id()).neighbor.get();
2271 neighbor_rule->setPoints(*pts);
2272
2273 // Attach this quadrature rule to all the _fe_face_neighbor FE objects. This
2274 // has to have garbage quadrature weights but that's ok because we never
2275 // actually use the JxW coming from these FE reinit'd objects, e.g. we use the
2276 // JxW coming from the element face reinit for DGKernels or we use the JxW
2277 // coming from reinit of the mortar segment element in the case of mortar
2278 setNeighborQRule(neighbor_rule, neighbor_dim);
2279
2280 // reinit neighbor face
2281 for (const auto & it : _fe_face_neighbor[neighbor_dim])
2282 {
2283 FEBase & fe_face_neighbor = *it.second;
2284 FEType fe_type = it.first;
2285 FEShapeData & fesd = *_fe_shape_data_face_neighbor[fe_type];
2286
2287 fe_face_neighbor.reinit(neighbor, neighbor_side, tolerance, pts, weights);
2288
2289 _current_fe_face_neighbor[fe_type] = &fe_face_neighbor;
2290
2291 fesd._phi.shallowCopy(const_cast<std::vector<std::vector<Real>> &>(fe_face_neighbor.get_phi()));
2292 fesd._grad_phi.shallowCopy(
2293 const_cast<std::vector<std::vector<RealGradient>> &>(fe_face_neighbor.get_dphi()));
2294 if (_need_second_derivative_neighbor.count(fe_type))
2295 fesd._second_phi.shallowCopy(
2296 const_cast<std::vector<std::vector<TensorValue<Real>>> &>(fe_face_neighbor.get_d2phi()));
2297 }
2298 for (const auto & it : _vector_fe_face_neighbor[neighbor_dim])
2299 {
2300 FEVectorBase & fe_face_neighbor = *it.second;
2301 const FEType & fe_type = it.first;
2302
2303 _current_vector_fe_face_neighbor[fe_type] = &fe_face_neighbor;
2304
2305 VectorFEShapeData & fesd = *_vector_fe_shape_data_face_neighbor[fe_type];
2306
2307 fe_face_neighbor.reinit(neighbor, neighbor_side, tolerance, pts, weights);
2308
2309 fesd._phi.shallowCopy(
2310 const_cast<std::vector<std::vector<VectorValue<Real>>> &>(fe_face_neighbor.get_phi()));
2311 fesd._grad_phi.shallowCopy(
2312 const_cast<std::vector<std::vector<TensorValue<Real>>> &>(fe_face_neighbor.get_dphi()));
2313 if (_need_second_derivative.count(fe_type))
2314 fesd._second_phi.shallowCopy(const_cast<std::vector<std::vector<TypeNTensor<3, Real>>> &>(
2315 fe_face_neighbor.get_d2phi()));
2316 if (_need_curl.count(fe_type))
2317 fesd._curl_phi.shallowCopy(const_cast<std::vector<std::vector<VectorValue<Real>>> &>(
2318 fe_face_neighbor.get_curl_phi()));
2319 if (_need_face_neighbor_div.count(fe_type))
2320 fesd._div_phi.shallowCopy(
2321 const_cast<std::vector<std::vector<Real>> &>(fe_face_neighbor.get_div_phi()));
2322 }
2324 {
2325 mooseAssert(neighbor_dim < _unique_fe_face_neighbor_helper.size(),
2326 "We should be in bounds here");
2327 _unique_fe_face_neighbor_helper[neighbor_dim]->reinit(
2328 neighbor, neighbor_side, tolerance, pts, weights);
2329 }
2330 // During that last loop the helper objects will have been reinitialized as well
2331 // We need to dig out the q_points from it
2333 const_cast<std::vector<Point> &>(_holder_fe_face_neighbor_helper[neighbor_dim]->get_xyz()));
2334}

Referenced by SubProblem::reinitNeighborFaceRef().

◆ reinitNeighborLowerDElem()

void Assembly::reinitNeighborLowerDElem ( const Elem *  elem)

reinitialize a neighboring lower dimensional element

Definition at line 2451 of file Assembly.C.

2452{
2453 mooseAssert(elem->dim() < _mesh_dimension,
2454 "You should be calling reinitNeighborLowerDElem on a lower dimensional element");
2455
2457
2459 return;
2460
2462 // We are in a Cartesian coordinate system and we can just use the element volume method which
2463 // has fast computation for certain element types
2465 else
2466 // We manually compute the volume taking the curvilinear coordinate transformations into
2467 // account
2469}

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

1112 {
1113 return _sub_Re[tag_id][var_num];
1114 }

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

1130 {
1131 return _sub_Rl[tag_id][var_num];
1132 }

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

1121 {
1122 return _sub_Rn[tag_id][var_num];
1123 }

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

1015{
1016 _ad_dxyzdxi_map.resize(n_qp);
1017 _ad_dxidx_map.resize(n_qp);
1018 _ad_dxidy_map.resize(n_qp); // 1D element may live in 2D ...
1019 _ad_dxidz_map.resize(n_qp); // ... or 3D
1020
1021 if (dim > 1)
1022 {
1023 _ad_dxyzdeta_map.resize(n_qp);
1024 _ad_detadx_map.resize(n_qp);
1025 _ad_detady_map.resize(n_qp);
1026 _ad_detadz_map.resize(n_qp);
1027
1028 if (dim > 2)
1029 {
1030 _ad_dxyzdzeta_map.resize(n_qp);
1031 _ad_dzetadx_map.resize(n_qp);
1032 _ad_dzetady_map.resize(n_qp);
1033 _ad_dzetadz_map.resize(n_qp);
1034 }
1035 }
1036
1037 _ad_jac.resize(n_qp);
1038 _ad_JxW.resize(n_qp);
1039 if (_calculate_xyz)
1040 _ad_q_points.resize(n_qp);
1041}

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
keThe local Jacobian
iThe local test function index
ntestThe number of test functions
jThe local shape function index
nphiThe number of shape functions
vThe diagonal Jacobian contribution on the current qp

Definition at line 1850 of file Assembly.h.

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

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
keThe local Jacobian
iThe local test function index
ntestThe number of test functions
jThe local shape function index
nphiThe number of shape functions
ivarThe array variable index
jvarThe contributing variable index
vThe full Jacobian contribution from a variable on the current qp

Definition at line 1875 of file Assembly.h.

1883 {
1884 if (ivar == jvar && _component_block_diagonal[ivar])
1885 {
1886 for (unsigned int k = 0; k < v.rows(); ++k, i += ntest)
1887 ke(i, j) += v(k, k);
1888 }
1889 else
1890 {
1891 const unsigned int saved_j = j;
1892 for (unsigned int k = 0; k < v.rows(); ++k, i += ntest)
1893 {
1894 j = saved_j;
1895 for (unsigned int l = 0; l < v.cols(); ++l, j += nphi)
1896 ke(i, j) += v(k, l);
1897 }
1898 }
1899 }

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

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

Referenced by ADArrayIntegratedBC::computeResidualsForJacobian(), and ADArrayKernel::computeResidualsForJacobian().

◆ 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
reThe local residual
iThe local test function index
ntestThe number of test functions
vThe residual contribution on the current qp

Definition at line 1826 of file Assembly.h.

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

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

◆ scalarFieldCouplingEntries()

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

Definition at line 1310 of file Assembly.h.

1311 {
1312 return _cm_sf_entry;
1313 }

Referenced by MortarScalarBase::computeScalarOffDiagJacobian().

◆ secondPhi() [1/6]

const VariablePhiSecond & Assembly::secondPhi ( ) const
inline

Definition at line 1326 of file Assembly.h.

1326{ return _second_phi; }
VariablePhiSecond _second_phi
Definition Assembly.h:2704

Referenced by copyShapes().

◆ secondPhi() [2/6]

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

Definition at line 1464 of file Assembly.h.

1464{ return _second_phi; }

◆ secondPhi() [3/6]

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

Definition at line 1327 of file Assembly.h.

1328 {
1329 return _second_phi;
1330 }

◆ secondPhi() [4/6]

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

Definition at line 1577 of file Assembly.h.

1577{ return _second_phi; }

◆ secondPhi() [5/6]

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

Definition at line 1499 of file Assembly.h.

1500 {
1501 return _vector_second_phi;
1502 }
VectorVariablePhiSecond _vector_second_phi
Definition Assembly.h:2721

◆ secondPhi() [6/6]

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

Definition at line 1378 of file Assembly.h.

1379 {
1380 return _vector_second_phi;
1381 }

◆ secondPhiFace() [1/5]

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

Definition at line 1468 of file Assembly.h.

1468{ return _second_phi_face; }
VariablePhiSecond _second_phi_face
Definition Assembly.h:2708

◆ secondPhiFace() [2/5]

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

Definition at line 1339 of file Assembly.h.

1340 {
1341 return _second_phi_face;
1342 }

Referenced by copyFaceShapes().

◆ secondPhiFace() [3/5]

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

Definition at line 1584 of file Assembly.h.

1585 {
1586 return _second_phi_face;
1587 }

◆ secondPhiFace() [4/5]

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

Definition at line 1520 of file Assembly.h.

1521 {
1523 }
VectorVariablePhiSecond _vector_second_phi_face
Definition Assembly.h:2727

◆ secondPhiFace() [5/5]

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

Definition at line 1399 of file Assembly.h.

1400 {
1402 }

◆ secondPhiFaceNeighbor() [1/5]

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

Definition at line 1488 of file Assembly.h.

1489 {
1491 }
VariablePhiSecond _second_phi_face_neighbor
Definition Assembly.h:2716

◆ secondPhiFaceNeighbor() [2/5]

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

Definition at line 1365 of file Assembly.h.

1366 {
1368 }

Referenced by copyNeighborShapes().

◆ secondPhiFaceNeighbor() [3/5]

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

Definition at line 1610 of file Assembly.h.

1611 {
1613 }

◆ secondPhiFaceNeighbor() [4/5]

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

Definition at line 1561 of file Assembly.h.

1562 {
1564 }
VectorVariablePhiSecond _vector_second_phi_face_neighbor
Definition Assembly.h:2739

◆ secondPhiFaceNeighbor() [5/5]

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

Definition at line 1446 of file Assembly.h.

1447 {
1449 }

◆ secondPhiNeighbor() [1/5]

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

Definition at line 1475 of file Assembly.h.

1476 {
1477 return _second_phi_neighbor;
1478 }
VariablePhiSecond _second_phi_neighbor
Definition Assembly.h:2712

◆ secondPhiNeighbor() [2/5]

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

Definition at line 1352 of file Assembly.h.

1353 {
1354 return _second_phi_neighbor;
1355 }

Referenced by copyNeighborShapes().

◆ secondPhiNeighbor() [3/5]

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

Definition at line 1597 of file Assembly.h.

1598 {
1599 return _second_phi_neighbor;
1600 }

◆ secondPhiNeighbor() [4/5]

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

Definition at line 1541 of file Assembly.h.

1542 {
1544 }
VectorVariablePhiSecond _vector_second_phi_neighbor
Definition Assembly.h:2733

◆ secondPhiNeighbor() [5/5]

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

Definition at line 1422 of file Assembly.h.

1423 {
1425 }

◆ setCachedJacobian()

void Assembly::setCachedJacobian ( GlobalDataKey  )

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

Definition at line 4542 of file Assembly.C.

4543{
4544 for (MooseIndex(_cached_jacobian_rows) tag = 0; tag < _cached_jacobian_rows.size(); tag++)
4545 if (_sys.hasMatrix(tag))
4546 {
4547 // First zero the rows (including the diagonals) to prepare for
4548 // setting the cached values.
4550
4551 // TODO: Use SparseMatrix::set_values() for efficiency
4552 for (MooseIndex(_cached_jacobian_values) i = 0; i < _cached_jacobian_values[tag].size(); ++i)
4554 _cached_jacobian_cols[tag][i],
4555 _cached_jacobian_values[tag][i]);
4556 }
4557
4559}
void clearCachedJacobian()
Clear any currently cached jacobians.
Definition Assembly.C:4572
virtual void zero_rows(std::vector< numeric_index_type > &rows, T diag_value=0.0)
virtual void set(const numeric_index_type i, const numeric_index_type j, const T value)=0

◆ setCoordinateTransformation() [1/2]

template<typename Points , typename Coords >
void Assembly::setCoordinateTransformation ( const libMesh::QBase *  qrule,
const Points &  q_points,
Coords &  coord,
SubdomainID  sub_id 
)
private

◆ setCoordinateTransformation() [2/2]

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

Definition at line 1776 of file Assembly.C.

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

◆ setCurrentBoundaryID()

void Assembly::setCurrentBoundaryID ( BoundaryID  i)
inline

set the current boundary ID

Definition at line 430 of file Assembly.h.

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

3263{
3264 _current_lower_d_elem = lower_d_elem;
3265}

Referenced by SubProblem::setCurrentLowerDElem().

◆ setCurrentNeighborSubdomainID()

void Assembly::setCurrentNeighborSubdomainID ( SubdomainID  i)
inline

set the current subdomain ID

Definition at line 498 of file Assembly.h.

Referenced by DisplacedProblem::setNeighborSubdomainID().

◆ setCurrentSubdomainID()

void Assembly::setCurrentSubdomainID ( SubdomainID  i)
inline

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

1976{
1977 const auto elem_dimension = elem->dim();
1979 auto rule = qruleFace(elem, side);
1980 if (_current_qrule_face != rule)
1981 setFaceQRule(rule, elem_dimension);
1982}

◆ 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
qruleThe qrule you want to set
dimThe spatial dimension of the qrule

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

◆ setLowerQRule()

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

Set the qrule to be used for lower dimensional integration.

Parameters
qruleThe qrule you want to set
dimThe spatial dimension of the qrule

Definition at line 727 of file Assembly.C.

728{
729 // The lower-dimensional quadrature rule matches the face quadrature rule
730 setFaceQRule(qrule, dim);
731
732 _current_qrule_lower = qrule;
733
734 for (auto & it : _fe_lower[dim])
735 it.second->attach_quadrature_rule(qrule);
736 for (auto & it : _vector_fe_lower[dim])
737 it.second->attach_quadrature_rule(qrule);
738 if (!_unique_fe_lower_helper.empty())
739 {
740 mooseAssert(dim < _unique_fe_lower_helper.size(), "We should not be indexing out of bounds");
741 _unique_fe_lower_helper[dim]->attach_quadrature_rule(qrule);
742 }
743}

Referenced by reinitLowerDElem().

◆ setMortarQRule()

void Assembly::setMortarQRule ( Order  order)

Specifies a custom qrule for integration on mortar segment mesh.

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

Definition at line 772 of file Assembly.C.

773{
774 if (order != _qrule_msm->get_order())
775 {
776 // If custom mortar qrule has not yet been specified
778 {
780 const unsigned int dim = _qrule_msm->get_dim();
781 const QuadratureType type = _qrule_msm->type();
782 delete _qrule_msm;
783
784 _qrule_msm = QBase::build(type, dim, order).release();
785 _fe_msm->attach_quadrature_rule(_qrule_msm);
786 }
787 else
788 mooseError("Mortar quadrature_order: ",
789 order,
790 " does not match previously specified quadrature_order: ",
792 ". Quadrature_order (when specified) must match for all mortar constraints.");
793 }
794}
Order get_order() const
virtual QuadratureType type() const=0
unsigned int get_dim() const

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
qruleThe qrule you want to set
dimThe spatial dimension of the qrule

Definition at line 746 of file Assembly.C.

747{
749
750 for (auto & it : _fe_face_neighbor[dim])
751 it.second->attach_quadrature_rule(qrule);
752 for (auto & it : _vector_fe_face_neighbor[dim])
753 it.second->attach_quadrature_rule(qrule);
755 {
756 mooseAssert(dim < _unique_fe_face_neighbor_helper.size(),
757 "We should not be indexing out of bounds");
758 _unique_fe_face_neighbor_helper[dim]->attach_quadrature_rule(qrule);
759 }
760}

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

3600{
3601 auto & tag_Re = _sub_Re[vector_tag._type_id];
3602 const std::vector<MooseVariableFEBase *> & vars = _sys.getVariables(_tid);
3603 for (const auto & var : vars)
3604 setResidualBlock(residual, tag_Re[var->number()], var->dofIndices(), var->arrayScalingFactor());
3605}
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.
Definition Assembly.C:3355

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

3359{
3360 if (dof_indices.size() > 0)
3361 {
3362 std::vector<dof_id_type> di(dof_indices);
3363 _tmp_Re = res_block;
3364 processLocalResidual(_tmp_Re, di, scaling_factor);
3365 residual.insert(_tmp_Re, di);
3366 }
3367}
virtual void insert(const T *v, const std::vector< numeric_index_type > &dof_indices)

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

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

◆ setVolumeQRule() [1/2]

void Assembly::setVolumeQRule ( const Elem *  elem)

Set the volumetric quadrature rule based on the provided element.

Definition at line 1854 of file Assembly.C.

1855{
1856 unsigned int elem_dimension = elem->dim();
1857 _current_qrule_volume = qrules(elem_dimension).vol.get();
1858 // Make sure the qrule is the right one
1860 setVolumeQRule(_current_qrule_volume, elem_dimension);
1861}

◆ 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
qruleThe qrule you want to set
dimThe spatial dimension of the qrule

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

◆ setXFEM()

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

Set the pointer to the XFEM controller object.

Definition at line 1810 of file Assembly.h.

1810{ _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 442 of file Assembly.h.

442{ return _current_side; }

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

◆ sideElem()

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

Returns the side element.

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

Definition at line 454 of file Assembly.h.

454{ 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 460 of file Assembly.h.

460{ 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 358 of file Assembly.h.

358{ return _current_tangents; }

◆ writeableQRule() [1/2]

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

Returns the reference to the current quadrature being used.

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

Definition at line 233 of file Assembly.h.

233{ return _current_qrule; }

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

◆ writeableQRule() [2/2]

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

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

Returns
A pointer.

Definition at line 240 of file Assembly.h.

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

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

318{ 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 325 of file Assembly.h.

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

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

523{ return _current_qrule_neighbor; }

◆ zeroCachedJacobian()

void Assembly::zeroCachedJacobian ( GlobalDataKey  )

Zero out previously-cached Jacobian rows.

Definition at line 4562 of file Assembly.C.

4563{
4564 for (MooseIndex(_cached_jacobian_rows) tag = 0; tag < _cached_jacobian_rows.size(); tag++)
4565 if (_sys.hasMatrix(tag))
4567
4569}

Member Data Documentation

◆ _ad_coord

MooseArray<ADReal> Assembly::_ad_coord
private

The AD version of the current coordinate transformation coefficients.

Definition at line 2425 of file Assembly.h.

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

◆ _ad_curvatures

MooseArray<ADReal> Assembly::_ad_curvatures
protected

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

Referenced by computeFaceMap().

◆ _ad_d2xyzdxi2_map

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

Definition at line 2843 of file Assembly.h.

Referenced by computeFaceMap().

◆ _ad_d2xyzdxideta_map

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

Definition at line 2844 of file Assembly.h.

Referenced by computeFaceMap().

◆ _ad_detadx_map

std::vector<ADReal> Assembly::_ad_detadx_map
protected

Definition at line 2852 of file Assembly.h.

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

◆ _ad_detady_map

std::vector<ADReal> Assembly::_ad_detady_map
protected

Definition at line 2853 of file Assembly.h.

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

◆ _ad_detadz_map

std::vector<ADReal> Assembly::_ad_detadz_map
protected

Definition at line 2854 of file Assembly.h.

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

◆ _ad_dxidx_map

std::vector<ADReal> Assembly::_ad_dxidx_map
protected

Definition at line 2849 of file Assembly.h.

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

◆ _ad_dxidy_map

std::vector<ADReal> Assembly::_ad_dxidy_map
protected

Definition at line 2850 of file Assembly.h.

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

◆ _ad_dxidz_map

std::vector<ADReal> Assembly::_ad_dxidz_map
protected

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

Referenced by computeSinglePointMapAD(), and resizeADMappingObjects().

◆ _ad_dzetadx_map

std::vector<ADReal> Assembly::_ad_dzetadx_map
protected

Definition at line 2855 of file Assembly.h.

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

◆ _ad_dzetady_map

std::vector<ADReal> Assembly::_ad_dzetady_map
protected

Definition at line 2856 of file Assembly.h.

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

◆ _ad_dzetadz_map

std::vector<ADReal> Assembly::_ad_dzetadz_map
protected

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

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

◆ _ad_jac

std::vector<ADReal> Assembly::_ad_jac
protected

Definition at line 2846 of file Assembly.h.

Referenced by computeSinglePointMapAD(), and resizeADMappingObjects().

◆ _ad_JxW

MooseArray<ADReal> Assembly::_ad_JxW
protected

◆ _ad_JxW_face

MooseArray<ADReal> Assembly::_ad_JxW_face
protected

Definition at line 2859 of file Assembly.h.

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

◆ _ad_normals

MooseArray<VectorValue<ADReal> > Assembly::_ad_normals
protected

Definition at line 2860 of file Assembly.h.

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

◆ _ad_q_points

MooseArray<VectorValue<ADReal> > Assembly::_ad_q_points
protected

◆ _ad_q_points_face

MooseArray<VectorValue<ADReal> > Assembly::_ad_q_points_face
protected

◆ _ad_vector_grad_phi_data

std::map<FEType, ADTemplateVariablePhiGradient<RealVectorValue> > Assembly::_ad_vector_grad_phi_data
mutableprotected

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

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

◆ _block_diagonal_matrix

bool Assembly::_block_diagonal_matrix
protected

◆ _building_helpers

bool Assembly::_building_helpers
private

Whether we are currently building the FE classes for the helpers.

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

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

◆ _cached_jacobian_rows

std::vector<std::vector<dof_id_type> > Assembly::_cached_jacobian_rows
protected

Row where the corresponding cached value should go.

Definition at line 2821 of file Assembly.h.

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

◆ _cached_jacobian_values

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

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

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

◆ _cached_residual_values

std::vector<std::vector<Real> > Assembly::_cached_residual_values
protected

Values cached by calling cacheResidual() (the first vector is for TIME vs NONTIME)

Definition at line 2811 of file Assembly.h.

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

◆ _calculate_ad_coord

bool Assembly::_calculate_ad_coord
mutableprotected

Whether to calculate coord with AD.

This will only be set to true if a consumer calls adCoordTransformation()

Definition at line 2876 of file Assembly.h.

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

◆ _calculate_curvatures

bool Assembly::_calculate_curvatures
mutableprotected

◆ _calculate_face_xyz

bool Assembly::_calculate_face_xyz
mutableprotected

Definition at line 2871 of file Assembly.h.

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

◆ _calculate_xyz

bool Assembly::_calculate_xyz
mutableprotected

◆ _cm

const libMesh::CouplingMatrix* Assembly::_cm
private

Coupling matrices.

Definition at line 2317 of file Assembly.h.

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

◆ _cm_ff_entry

std::vector<std::pair<MooseVariableFieldBase *, MooseVariableFieldBase *> > Assembly::_cm_ff_entry
private

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

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

◆ _cm_nonlocal_entry

std::vector<std::pair<MooseVariableFieldBase *, MooseVariableFieldBase *> > Assembly::_cm_nonlocal_entry
private

Entries in the coupling matrix for field variables for nonlocal calculations.

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

Referenced by addJacobian(), addJacobianOffDiagScalar(), cacheJacobian(), and scalarFieldCouplingEntries().

◆ _cm_ss_entry

std::vector<std::pair<MooseVariableScalar *, MooseVariableScalar *> > Assembly::_cm_ss_entry
private

Entries in the coupling matrix for scalar variables.

Definition at line 2336 of file Assembly.h.

Referenced by addJacobianScalar().

◆ _column_indices

std::vector<dof_id_type> Assembly::_column_indices
protected

Definition at line 2908 of file Assembly.h.

Referenced by cacheJacobian(), and cacheJacobianBlock().

◆ _component_block_diagonal

std::vector<bool> Assembly::_component_block_diagonal
protected

◆ _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 2891 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 2324 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 2321 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 2327 of file Assembly.h.

Referenced by computingResidualAndJacobian().

◆ _coord

MooseArray<Real> Assembly::_coord
private

The current coordinate transformation coefficients.

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

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

◆ _coord_type

Moose::CoordinateSystemType Assembly::_coord_type
private

The coordinate system.

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

Referenced by currentBoundaryID(), and setCurrentBoundaryID().

◆ _current_elem

const Elem* Assembly::_current_elem
protected

◆ _current_elem_volume

Real Assembly::_current_elem_volume
protected

Volume of the current element.

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

Referenced by computeCurrentElemVolume(), reinit(), reinit(), reinit(), reinit(), reinitAtPhysical(), and reinitFVFace().

◆ _current_fe

std::map<FEType, FEBase *> Assembly::_current_fe
private

The "volume" fe object that matches the current elem.

Definition at line 2381 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 2383 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 2519 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 2387 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 2407 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 2385 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 2419 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 2527 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 2568 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 2630 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 2636 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 2609 of file Assembly.h.

Referenced by neighbor(), reinit(), reinit(), reinit(), reinit(), reinitAtPhysical(), reinitFVFace(), reinitNeighbor(), and reinitNeighborFaceRef().

◆ _current_neighbor_lower_d_elem

const Elem* Assembly::_current_neighbor_lower_d_elem
protected

The current neighboring lower dimensional element.

Definition at line 2632 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 2640 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 2623 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 2914 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 2613 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 2615 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 2889 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 2611 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 2619 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 2621 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 2529 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 2645 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 2417 of file Assembly.h.

Referenced by computeCurrentElemVolume(), modifyWeightsDueToXFEM(), qPoints(), and reinitFE().

◆ _current_q_points_face

MooseArray<Point> Assembly::_current_q_points_face
private

◆ _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 2564 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 2523 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 2409 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 2413 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 2415 of file Assembly.h.

Referenced by reinit().

◆ _current_qrule_face

libMesh::QBase* Assembly::_current_qrule_face
private

◆ _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 2591 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 2562 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 2411 of file Assembly.h.

Referenced by setVolumeQRule().

◆ _current_side

unsigned int Assembly::_current_side
protected

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

Definition at line 2603 of file Assembly.h.

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

◆ _current_side_elem

const Elem* Assembly::_current_side_elem
protected

The current "element" making up the side we are currently on.

Definition at line 2605 of file Assembly.h.

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

◆ _current_side_elem_builder

libMesh::ElemSideBuilder Assembly::_current_side_elem_builder
protected

In place side element builder for _current_side_elem.

Definition at line 2887 of file Assembly.h.

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

◆ _current_side_volume

Real Assembly::_current_side_volume
protected

Volume of the current side element.

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

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

◆ _current_subdomain_id

SubdomainID Assembly::_current_subdomain_id
protected

The current subdomain ID.

Definition at line 2597 of file Assembly.h.

Referenced by currentSubdomainID(), qrules(), reinit(), reinit(), reinit(), reinit(), reinitAtPhysical(), reinitFVFace(), and setCurrentSubdomainID().

◆ _current_tangents

MooseArray<std::vector<Point> > Assembly::_current_tangents
private

The current tangent vectors at the quadrature points.

Definition at line 2533 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 2390 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 2392 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 2396 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 2394 of file Assembly.h.

Referenced by reinitFENeighbor().

◆ _curvatures

MooseArray<Real> Assembly::_curvatures
protected

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

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

◆ _displaced

const bool Assembly::_displaced
private

Definition at line 2314 of file Assembly.h.

Referenced by computeADFace(), and reinitFE().

◆ _dof_map

const libMesh::DofMap& Assembly::_dof_map
private

◆ _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 2903 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 2898 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 2536 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 2401 of file Assembly.h.

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

◆ _fe_face

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

types of finite elements

Definition at line 2513 of file Assembly.h.

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

◆ _fe_face_neighbor

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

◆ _fe_lower

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

FE objects for lower dimensional elements.

Definition at line 2555 of file Assembly.h.

Referenced by Assembly(), buildLowerDDualFE(), buildLowerDFE(), preparePRefinement(), reinitDual(), reinitLowerDElem(), setLowerQRule(), and ~Assembly().

◆ _fe_msm

std::unique_ptr<FEBase> Assembly::_fe_msm
private

A FE object for working on mortar segement elements.

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

Referenced by Assembly(), buildNeighborFE(), getFENeighbor(), preparePRefinement(), reinitFENeighbor(), and ~Assembly().

◆ _fe_shape_data

std::map<FEType, std::unique_ptr<FEShapeData> > Assembly::_fe_shape_data
mutableprotected

Shape function values, gradients, second derivatives for each FE type.

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

◆ _fe_shape_data_face

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

◆ _fe_shape_data_face_neighbor

std::map<FEType, std::unique_ptr<FEShapeData> > Assembly::_fe_shape_data_face_neighbor
mutableprotected

◆ _fe_shape_data_lower

std::map<FEType, std::unique_ptr<FEShapeData> > Assembly::_fe_shape_data_lower
mutableprotected

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

◆ _grad_phi

VariablePhiGradient Assembly::_grad_phi
protected

Definition at line 2703 of file Assembly.h.

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

◆ _grad_phi_face

VariablePhiGradient Assembly::_grad_phi_face
protected

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

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

◆ _grad_phi_neighbor

VariablePhiGradient Assembly::_grad_phi_neighbor
protected

Definition at line 2711 of file Assembly.h.

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

◆ _helper_type

const FEType Assembly::_helper_type
private

The finite element type of the FE helper classes.

The helper class gives us data like JxW, the physical quadrature point locations, etc.

Definition at line 2357 of file Assembly.h.

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

◆ _holder_fe_face_helper

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

Each dimension's helper objects.

Definition at line 2517 of file Assembly.h.

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

◆ _holder_fe_face_neighbor_helper

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

◆ _holder_fe_helper

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

Each dimension's helper objects.

Definition at line 2405 of file Assembly.h.

Referenced by Assembly(), helpersRequestData(), preparePRefinement(), and reinitFE().

◆ _holder_fe_lower_helper

std::map<unsigned int, FEBase *> Assembly::_holder_fe_lower_helper
private

helper object for transforming coordinates for lower dimensional element quadrature points

Definition at line 2559 of file Assembly.h.

Referenced by Assembly(), helpersRequestData(), preparePRefinement(), and reinitLowerDElem().

◆ _holder_fe_neighbor_helper

std::map<unsigned int, FEBase *> Assembly::_holder_fe_neighbor_helper
private

Each dimension's helper objects.

Definition at line 2551 of file Assembly.h.

Referenced by Assembly(), helpersRequestData(), preparePRefinement(), and reinitNeighbor().

◆ _holder_normals

std::map<unsigned int, const std::vector<Point> *> Assembly::_holder_normals
private

Holds pointers to the dimension's normal vectors.

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

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

◆ _jacobian_block_neighbor_used

std::vector<std::vector<std::vector<unsigned char> > > Assembly::_jacobian_block_neighbor_used
private

Flag that indicates if the jacobian block for neighbor was used.

Definition at line 2343 of file Assembly.h.

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

◆ _jacobian_block_nonlocal_used

std::vector<std::vector<std::vector<unsigned char> > > Assembly::_jacobian_block_nonlocal_used
private

◆ _jacobian_block_used

std::vector<std::vector<std::vector<unsigned char> > > Assembly::_jacobian_block_used
private

◆ _JxW_msm

const std::vector<Real>* Assembly::_JxW_msm
private

A JxW for working on mortar segement elements.

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

Referenced by mappedNormals(), and reinitFEFace().

◆ _max_cached_jacobians

unsigned int Assembly::_max_cached_jacobians
protected

Definition at line 2825 of file Assembly.h.

Referenced by addCachedJacobian().

◆ _max_cached_residuals

unsigned int Assembly::_max_cached_residuals
protected

Definition at line 2816 of file Assembly.h.

Referenced by clearCachedResiduals().

◆ _mesh

MooseMesh& Assembly::_mesh
private

Definition at line 2351 of file Assembly.h.

Referenced by Assembly().

◆ _mesh_dimension

unsigned int Assembly::_mesh_dimension
private

◆ _msm_elem

const Elem* Assembly::_msm_elem = nullptr
protected

Definition at line 2893 of file Assembly.h.

Referenced by msmElem(), and reinitMortarElem().

◆ _need_ad_face_map

bool Assembly::_need_ad_face_map = false
mutableprotected

Whether any object needs the AD face JxW, normals, quadrature points, curvatures or coordinate transformation, which computeFaceMap provides on displaced meshes.

Definition at line 2797 of file Assembly.h.

Referenced by adCoordTransformation(), adCurvatures(), adJxWFace(), adNormals(), adQPointsFace(), and computeADFace().

◆ _need_ad_grad_phi

bool Assembly::_need_ad_grad_phi = false
mutableprotected

Whether any object needs the AD element shape function gradients.

Definition at line 2789 of file Assembly.h.

Referenced by adGradPhi(), adGradPhi(), needADGradPhi(), and reinitFE().

◆ _need_ad_grad_phi_face

bool Assembly::_need_ad_grad_phi_face = false
mutableprotected

Whether any object needs the AD face shape function gradients.

Computing them on a displaced mesh propagates the displacement derivatives of the face map into every shape function gradient, which is expensive and unnecessary when only values and normals are used.

Definition at line 2787 of file Assembly.h.

Referenced by computeADFace(), and needADGradPhiFace().

◆ _need_ad_volume_map

bool Assembly::_need_ad_volume_map = false
mutableprotected

Whether any object needs the AD element JxW, quadrature points or coordinate transformation.

On a displaced mesh their map carries derivatives for every element node displacement. That costs time even when no object reads them, and it needs an AD derivative size of at least the element's displacement dofs (81 on a HEX27).

Definition at line 2794 of file Assembly.h.

Referenced by adCoordTransformation(), adJxW(), adQPoints(), and reinitFE().

◆ _need_curl

std::set<FEType> Assembly::_need_curl
mutableprotected

◆ _need_div

std::set<FEType> Assembly::_need_div
mutableprotected

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

Referenced by activateDual(), and needDual().

◆ _need_face_div

std::set<FEType> Assembly::_need_face_div
mutableprotected

Definition at line 2882 of file Assembly.h.

Referenced by buildVectorFaceFE(), reinitElemFaceRef(), and reinitFEFace().

◆ _need_face_neighbor_div

std::set<FEType> Assembly::_need_face_neighbor_div
mutableprotected

◆ _need_JxW_neighbor

bool Assembly::_need_JxW_neighbor
mutableprivate

Flag to indicate that JxW_neighbor is needed.

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

Referenced by lowerDElemVolume(), and reinitLowerDElem().

◆ _need_neighbor_div

std::set<FEType> Assembly::_need_neighbor_div
mutableprotected

Definition at line 2883 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 2617 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 2638 of file Assembly.h.

Referenced by neighborLowerDElemVolume(), and reinitNeighborLowerDElem().

◆ _need_second_derivative

std::set<FEType> Assembly::_need_second_derivative
mutableprotected

◆ _need_second_derivative_neighbor

std::set<FEType> Assembly::_need_second_derivative_neighbor
mutableprotected

◆ _neighbor_extra_elem_ids

std::vector<dof_id_type> Assembly::_neighbor_extra_elem_ids
private

Extra element IDs of neighbor.

Definition at line 2538 of file Assembly.h.

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

◆ _nonlocal_cm

const libMesh::CouplingMatrix& Assembly::_nonlocal_cm
private

Definition at line 2318 of file Assembly.h.

Referenced by initNonlocalCoupling().

◆ _phi

VariablePhiValue Assembly::_phi
protected

Definition at line 2702 of file Assembly.h.

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

◆ _phi_face

VariablePhiValue Assembly::_phi_face
protected

Definition at line 2706 of file Assembly.h.

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

◆ _phi_face_neighbor

VariablePhiValue Assembly::_phi_face_neighbor
protected

Definition at line 2714 of file Assembly.h.

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

◆ _phi_neighbor

VariablePhiValue Assembly::_phi_neighbor
protected

Definition at line 2710 of file Assembly.h.

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

◆ _prepared_for_p_refinement

bool Assembly::_prepared_for_p_refinement
protected

Whether helper FEs have been prepared for p-refinement.

Definition at line 2911 of file Assembly.h.

Referenced by preparePRefinement().

◆ _qrule_msm

libMesh::QBase* Assembly::_qrule_msm
private

A qrule object for working on mortar segement elements.

This needs to be a raw pointer because we need to be able to return a reference to it because we will be constructing other objects that need the qrule before the qrule is actually created

Definition at line 2585 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 2458 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 2808 of file Assembly.h.

Referenced by clearCachedResiduals().

◆ _row_indices

std::vector<dof_id_type> Assembly::_row_indices
protected

Working vectors to avoid repeated heap allocations when caching residuals/Jacobians that must have libMesh-level constraints (hanging nodes, periodic bcs) applied to them.

These are for storing the dof indices

Definition at line 2908 of file Assembly.h.

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

◆ _second_phi

VariablePhiSecond Assembly::_second_phi
protected

Definition at line 2704 of file Assembly.h.

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

◆ _second_phi_face

VariablePhiSecond Assembly::_second_phi_face
protected

Definition at line 2708 of file Assembly.h.

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

◆ _second_phi_face_neighbor

VariablePhiSecond Assembly::_second_phi_face_neighbor
protected

◆ _second_phi_neighbor

VariablePhiSecond Assembly::_second_phi_neighbor
protected

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

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

◆ _sub_Keg

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

Definition at line 2679 of file Assembly.h.

Referenced by jacobianBlockNonlocal().

◆ _sub_Kel

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

dsecondary/dlower (or delement/dlower)

Definition at line 2694 of file Assembly.h.

Referenced by jacobianBlockMortar().

◆ _sub_Ken

std::vector<std::vector<std::vector<DenseMatrix<Number> > > > Assembly::_sub_Ken
protected

jacobian contributions from the element and neighbor <Tag, ivar, jvar>

Definition at line 2682 of file Assembly.h.

Referenced by jacobianBlockMortar(), and jacobianBlockNeighbor().

◆ _sub_Kle

std::vector<std::vector<std::vector<DenseMatrix<Number> > > > Assembly::_sub_Kle
protected

dlower/dsecondary (or dlower/delement)

Definition at line 2690 of file Assembly.h.

Referenced by jacobianBlockMortar().

◆ _sub_Kll

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

dlower/dlower

Definition at line 2688 of file Assembly.h.

Referenced by jacobianBlockMortar().

◆ _sub_Kln

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

dlower/dprimary (or dlower/dneighbor)

Definition at line 2692 of file Assembly.h.

Referenced by jacobianBlockMortar().

◆ _sub_Kne

std::vector<std::vector<std::vector<DenseMatrix<Number> > > > Assembly::_sub_Kne
protected

jacobian contributions from the neighbor and element <Tag, ivar, jvar>

Definition at line 2684 of file Assembly.h.

Referenced by jacobianBlockMortar(), and jacobianBlockNeighbor().

◆ _sub_Knl

std::vector<std::vector<std::vector<DenseMatrix<Number> > > > Assembly::_sub_Knl
protected

dprimary/dlower (or dneighbor/dlower)

Definition at line 2696 of file Assembly.h.

Referenced by jacobianBlockMortar().

◆ _sub_Knn

std::vector<std::vector<std::vector<DenseMatrix<Number> > > > Assembly::_sub_Knn
protected

jacobian contributions from the neighbor <Tag, ivar, jvar>

Definition at line 2686 of file Assembly.h.

Referenced by jacobianBlockMortar(), and jacobianBlockNeighbor().

◆ _sub_Re

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

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

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

◆ _sub_Rn

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

◆ _subproblem

SubProblem& Assembly::_subproblem
private

◆ _sys

SystemBase& Assembly::_sys
private

◆ _temp_dof_indices

std::vector<dof_id_type> Assembly::_temp_dof_indices
protected

Temporary work vector to keep from reallocating it.

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

Referenced by reinitAtPhysical().

◆ _tid

THREAD_ID Assembly::_tid
private

◆ _tmp_Ke

DenseMatrix<Number> Assembly::_tmp_Ke
protected

auxiliary matrix for scaling jacobians (optimization to avoid expensive construction/destruction)

Definition at line 2699 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 2665 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 2369 of file Assembly.h.

Referenced by preparePRefinement(), reinitElemFaceRef(), and reinitFEFace().

◆ _unique_fe_face_neighbor_helper

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

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

Referenced by preparePRefinement(), and reinitFE().

◆ _unique_fe_lower_helper

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

Definition at line 2372 of file Assembly.h.

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

◆ _unique_fe_neighbor_helper

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

Definition at line 2371 of file Assembly.h.

Referenced by preparePRefinement(), and reinitFENeighbor().

◆ _user_added_fe_face_neighbor_of_helper_type

bool Assembly::_user_added_fe_face_neighbor_of_helper_type
mutableprivate

Definition at line 2362 of file Assembly.h.

Referenced by buildFaceNeighborFE(), and preparePRefinement().

◆ _user_added_fe_face_of_helper_type

bool Assembly::_user_added_fe_face_of_helper_type
mutableprivate

Definition at line 2361 of file Assembly.h.

Referenced by buildFaceFE(), and preparePRefinement().

◆ _user_added_fe_lower_of_helper_type

bool Assembly::_user_added_fe_lower_of_helper_type
mutableprivate

Definition at line 2364 of file Assembly.h.

Referenced by buildLowerDFE(), and preparePRefinement().

◆ _user_added_fe_neighbor_of_helper_type

bool Assembly::_user_added_fe_neighbor_of_helper_type
mutableprivate

Definition at line 2363 of file Assembly.h.

Referenced by buildNeighborFE(), and preparePRefinement().

◆ _user_added_fe_of_helper_type

bool Assembly::_user_added_fe_of_helper_type
mutableprivate

Whether user code requested a FEType the same as our _helper_type.

Definition at line 2360 of file Assembly.h.

Referenced by buildFE(), and preparePRefinement().

◆ _vector_curl_phi

VectorVariablePhiCurl Assembly::_vector_curl_phi
protected

Definition at line 2722 of file Assembly.h.

Referenced by curlPhi(), and curlPhi().

◆ _vector_curl_phi_face

VectorVariablePhiCurl Assembly::_vector_curl_phi_face
protected

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

Referenced by curlPhiFaceNeighbor(), and curlPhiFaceNeighbor().

◆ _vector_curl_phi_neighbor

VectorVariablePhiCurl Assembly::_vector_curl_phi_neighbor
protected

Definition at line 2734 of file Assembly.h.

Referenced by curlPhiNeighbor(), and curlPhiNeighbor().

◆ _vector_div_phi

VectorVariablePhiDivergence Assembly::_vector_div_phi
protected

Definition at line 2723 of file Assembly.h.

Referenced by divPhi(), and divPhi().

◆ _vector_div_phi_face

VectorVariablePhiDivergence Assembly::_vector_div_phi_face
protected

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

Referenced by divPhiFaceNeighbor(), and divPhiFaceNeighbor().

◆ _vector_div_phi_neighbor

VectorVariablePhiDivergence Assembly::_vector_div_phi_neighbor
protected

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

Referenced by buildVectorFE(), getVectorFE(), reinitFE(), and ~Assembly().

◆ _vector_fe_face

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

types of vector finite elements

Definition at line 2515 of file Assembly.h.

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

◆ _vector_fe_face_neighbor

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

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

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

◆ _vector_fe_neighbor

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

◆ _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 2772 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 2777 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 2773 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

◆ _vector_fe_shape_data_lower

std::map<FEType, std::unique_ptr<VectorFEShapeData> > Assembly::_vector_fe_shape_data_lower
mutableprotected

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

Referenced by buildVectorNeighborFE(), and reinitFENeighbor().

◆ _vector_grad_phi

VectorVariablePhiGradient Assembly::_vector_grad_phi
protected

Definition at line 2720 of file Assembly.h.

Referenced by gradPhi(), and gradPhi().

◆ _vector_grad_phi_face

VectorVariablePhiGradient Assembly::_vector_grad_phi_face
protected

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

Referenced by gradPhiFaceNeighbor(), and gradPhiFaceNeighbor().

◆ _vector_grad_phi_neighbor

VectorVariablePhiGradient Assembly::_vector_grad_phi_neighbor
protected

Definition at line 2732 of file Assembly.h.

Referenced by gradPhiNeighbor(), and gradPhiNeighbor().

◆ _vector_phi

VectorVariablePhiValue Assembly::_vector_phi
protected

Definition at line 2719 of file Assembly.h.

Referenced by phi(), and phi().

◆ _vector_phi_face

VectorVariablePhiValue Assembly::_vector_phi_face
protected

Definition at line 2725 of file Assembly.h.

Referenced by phiFace(), and phiFace().

◆ _vector_phi_face_neighbor

VectorVariablePhiValue Assembly::_vector_phi_face_neighbor
protected

Definition at line 2737 of file Assembly.h.

Referenced by phiFaceNeighbor(), and phiFaceNeighbor().

◆ _vector_phi_neighbor

VectorVariablePhiValue Assembly::_vector_phi_neighbor
protected

Definition at line 2731 of file Assembly.h.

Referenced by phiNeighbor(), and phiNeighbor().

◆ _vector_second_phi

VectorVariablePhiSecond Assembly::_vector_second_phi
protected

Definition at line 2721 of file Assembly.h.

Referenced by secondPhi(), and secondPhi().

◆ _vector_second_phi_face

VectorVariablePhiSecond Assembly::_vector_second_phi_face
protected

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

Referenced by secondPhiFaceNeighbor(), and secondPhiFaceNeighbor().

◆ _vector_second_phi_neighbor

VectorVariablePhiSecond Assembly::_vector_second_phi_neighbor
protected

Definition at line 2733 of file Assembly.h.

Referenced by secondPhiNeighbor(), and secondPhiNeighbor().

◆ _xfem

std::shared_ptr<XFEMInterface> Assembly::_xfem
private

The XFEM controller.

Definition at line 2378 of file Assembly.h.

Referenced by modifyFaceWeightsDueToXFEM(), modifyWeightsDueToXFEM(), reinitFE(), reinitFEFace(), and setXFEM().


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