18 #include "libmesh/dense_vector.h" 19 #include "libmesh/enum_quadrature_type.h" 20 #include "libmesh/fe_type.h" 21 #include "libmesh/point.h" 22 #include "libmesh/fe_base.h" 23 #include "libmesh/numeric_vector.h" 24 #include "libmesh/elem_side_builder.h" 28 #include <unordered_map> 75 template <
typename P,
typename C>
82 template <
typename P,
typename C>
103 template <
typename T>
106 const T *
const * ptr = &inref;
333 mooseAssert(
id <
_extra_elem_ids.size(),
"An invalid extra element integer id");
360 template <
bool is_ad>
516 bool allow_negative_qweights =
true);
617 unsigned int elem_side,
619 const std::vector<Point> *
const pts =
nullptr,
620 const std::vector<Real> *
const weights =
nullptr);
627 unsigned int neighbor_side,
629 const std::vector<Point> *
const pts,
630 const std::vector<Real> *
const weights =
nullptr);
635 void reinitDual(
const Elem *
elem,
const std::vector<Point> & pts,
const std::vector<Real> &
JxW);
641 const std::vector<Point> *
const pts =
nullptr,
642 const std::vector<Real> *
const weights =
nullptr);
679 void reinit(
const Elem *
elem,
const std::vector<Point> & reference_points);
694 void reinit(
const Elem *
elem,
unsigned int side,
const std::vector<Point> & reference_points);
712 unsigned int neighbor_side,
713 const std::vector<Point> * neighbor_reference_points =
nullptr);
719 unsigned int neighbor_side,
720 const std::vector<Point> & physical_points);
740 void init(
const CouplingMatrix * cm);
769 void prepareBlock(
unsigned int ivar,
unsigned jvar,
const std::vector<dof_id_type> & dof_indices);
772 const std::vector<dof_id_type> & idof_indices,
773 const std::vector<dof_id_type> & jdof_indices);
777 template <
typename T>
781 template <
typename T>
785 template <
typename T>
825 void addResidual(GlobalDataKey,
const std::vector<VectorTag> & vector_tags);
835 void addResidualLower(GlobalDataKey,
const std::vector<VectorTag> & vector_tags);
841 void addResidualScalar(GlobalDataKey,
const std::vector<VectorTag> & vector_tags);
847 void cacheResidual(GlobalDataKey,
const std::vector<VectorTag> & tags);
933 const DofMap & dof_map,
934 std::vector<dof_id_type> & dof_indices,
945 const DofMap & dof_map,
946 std::vector<dof_id_type> & dof_indices,
948 const std::set<TagID> & tags);
956 const DofMap & dof_map,
957 const std::vector<dof_id_type> & idof_indices,
958 const std::vector<dof_id_type> & jdof_indices,
968 const DofMap & dof_map,
969 const std::vector<dof_id_type> & idof_indices,
970 const std::vector<dof_id_type> & jdof_indices,
972 const std::set<TagID> & tags);
1008 const DofMap & dof_map,
1009 std::vector<dof_id_type> & dof_indices,
1010 std::vector<dof_id_type> & neighbor_dof_indices,
1021 const DofMap & dof_map,
1022 std::vector<dof_id_type> & dof_indices,
1023 std::vector<dof_id_type> & neighbor_dof_indices,
1025 const std::set<TagID> & tags);
1067 return _sub_Re[tag_id][var_num];
1076 return _sub_Rn[tag_id][var_num];
1085 return _sub_Rl[tag_id][var_num];
1134 const std::vector<dof_id_type> & dof_index,
1167 const std::set<TagID> & tags);
1176 const std::vector<dof_id_type> & idof_indices,
1177 const std::vector<dof_id_type> & jdof_indices,
1178 Real scaling_factor,
1191 template <
typename Res
iduals,
typename Indices>
1193 const Indices & row_indices,
1194 Real scaling_factor,
1196 const std::set<TagID> & vector_tags);
1205 template <
typename Res
iduals,
typename Indices>
1207 const Indices & row_indices,
1208 Real scaling_factor,
1210 const std::set<TagID> & matrix_tags);
1222 template <
typename Res
iduals,
typename Indices>
1224 const Indices & row_indices,
1225 Real scaling_factor,
1227 const std::set<TagID> & vector_tags);
1236 template <
typename Res
iduals,
typename Indices>
1238 const Indices & row_indices,
1239 Real scaling_factor,
1241 const std::set<TagID> & matrix_tags);
1243 std::vector<std::pair<MooseVariableFieldBase *, MooseVariableFieldBase *>> &
couplingEntries()
1247 const std::vector<std::pair<MooseVariableFieldBase *, MooseVariableFieldBase *>> &
1252 std::vector<std::pair<MooseVariableFieldBase *, MooseVariableFieldBase *>> &
1257 const std::vector<std::pair<MooseVariableFieldBase *, MooseVariableScalar *>> &
1262 const std::vector<std::pair<MooseVariableScalar *, MooseVariableFieldBase *>> &
1270 template <
typename T>
1567 template <
typename OutputType>
1574 template <
typename OutputType>
1581 template <
typename OutputType>
1587 template <
typename OutputType>
1595 template <
typename OutputType>
1598 template <
typename OutputType>
1601 template <
typename OutputType>
1604 template <
typename OutputType>
1608 template <
typename OutputType>
1615 template <
typename OutputType>
1622 template <
typename OutputType>
1628 template <
typename OutputType>
1636 template <
typename OutputType>
1643 template <
typename OutputType>
1650 template <
typename OutputType>
1658 template <
typename OutputType>
1665 template <
typename OutputType>
1673 template <
typename OutputType>
1682 template <
typename OutputType>
1690 template <
typename OutputType>
1698 template <
typename OutputType>
1706 template <
typename OutputType>
1714 template <
typename OutputType>
1722 template <
typename OutputType>
1730 template <
typename OutputType>
1739 template <
typename OutputType>
1760 std::vector<std::pair<unsigned int, unsigned short>> && disp_numbers_and_directions);
1775 for (
unsigned int j = 0; j < v.size(); ++j, i += ntest)
1798 for (
unsigned int k = 0; k < v.size(); ++k, i += ntest, j += pace)
1825 for (
unsigned int k = 0; k < v.rows(); ++k, i += ntest)
1826 ke(i, j) += v(k, k);
1830 const unsigned int saved_j = j;
1831 for (
unsigned int k = 0; k < v.rows(); ++k, i += ntest)
1834 for (
unsigned int l = 0; l < v.cols(); ++l, j += nphi)
1835 ke(i, j) += v(k, l);
1842 unsigned int rows = ke.
m();
1843 unsigned int cols = ke.
n();
1844 DenseVector<Real> diag(rows);
1845 for (
unsigned int i = 0; i < rows; i++)
1847 diag(i) = ke(i, i % cols);
1859 fe.attach_quadrature_rule(qrule);
1871 fe.attach_quadrature_rule(qrule);
1920 void havePRefinement(
const std::vector<FEFamily> & disable_p_refinement_for_families);
1949 template <
typename Po
ints,
typename Coords>
1951 const Points & q_points,
1980 template <
typename OutputType>
1984 FEGenericBase<OutputType> * fe);
2046 std::vector<dof_id_type> & dof_indices,
2047 const std::vector<Real> & scaling_factor,
2055 const std::vector<dof_id_type> & dof_indices,
2056 const std::vector<Real> & scaling_factor,
2063 std::vector<dof_id_type> & cached_residual_rows,
2065 const std::vector<dof_id_type> & dof_indices,
2066 const std::vector<Real> & scaling_factor,
2074 const std::vector<dof_id_type> & dof_indices,
2075 const std::vector<Real> & scaling_factor,
2085 const std::vector<dof_id_type> & idof_indices,
2086 const std::vector<dof_id_type> & jdof_indices);
2094 const std::vector<dof_id_type> & idof_indices,
2095 const std::vector<dof_id_type> & jdof_indices,
2104 const std::vector<dof_id_type> & idof_indices,
2105 const std::vector<dof_id_type> & jdof_indices,
2129 void buildFE(FEType type)
const;
2284 std::vector<std::pair<MooseVariableFieldBase *, MooseVariableFieldBase *>>
_cm_ff_entry;
2286 std::vector<std::pair<MooseVariableFieldBase *, MooseVariableScalar *>>
_cm_fs_entry;
2288 std::vector<std::pair<MooseVariableScalar *, MooseVariableFieldBase *>>
_cm_sf_entry;
2290 std::vector<std::pair<MooseVariableScalar *, MooseVariableScalar *>>
_cm_ss_entry;
2355 mutable std::map<unsigned int, std::map<FEType, FEBase *>>
_fe;
2357 mutable std::map<unsigned int, std::map<FEType, FEVectorBase *>>
_vector_fe;
2412 std::unordered_map<SubdomainID, std::vector<QRules>>
_qrules;
2423 template <
typename T>
2433 auto neighbor_block =
neighbor->subdomain_id();
2434 if (neighbor_block ==
elem->subdomain_id())
2437 auto q_neighbor = rule_fn(
qrules(
dim, neighbor_block));
2438 if (q->get_order() > q_neighbor->get_order())
2453 "missing quadrature rules for specified block");
2455 "quadrature rules not sized property for dimension");
2459 "missing quadrature rules for specified block");
2460 mooseAssert(
_qrules[block].size() >
dim,
"quadrature rules not sized property for dimension");
2467 mutable std::map<unsigned int, std::map<FEType, FEBase *>>
_fe_face;
2509 mutable std::map<unsigned int, std::map<FEType, FEBase *>>
_fe_lower;
2613 std::vector<std::vector<DenseVector<Number>>>
_sub_Re;
2614 std::vector<std::vector<DenseVector<Number>>>
_sub_Rn;
2616 std::vector<std::vector<DenseVector<Number>>>
_sub_Rl;
2632 std::vector<std::vector<std::vector<DenseMatrix<Number>>>>
_sub_Kee;
2633 std::vector<std::vector<std::vector<DenseMatrix<Number>>>>
_sub_Keg;
2636 std::vector<std::vector<std::vector<DenseMatrix<Number>>>>
_sub_Ken;
2638 std::vector<std::vector<std::vector<DenseMatrix<Number>>>>
_sub_Kne;
2640 std::vector<std::vector<std::vector<DenseMatrix<Number>>>>
_sub_Knn;
2642 std::vector<std::vector<std::vector<DenseMatrix<Number>>>>
_sub_Kll;
2644 std::vector<std::vector<std::vector<DenseMatrix<Number>>>>
_sub_Kle;
2646 std::vector<std::vector<std::vector<DenseMatrix<Number>>>>
_sub_Kln;
2648 std::vector<std::vector<std::vector<DenseMatrix<Number>>>>
_sub_Kel;
2650 std::vector<std::vector<std::vector<DenseMatrix<Number>>>>
_sub_Knl;
2736 mutable std::map<FEType, ADTemplateVariablePhiGradient<RealVectorValue>>
2857 template <
typename OutputType>
2865 template <
typename OutputType>
2873 template <
typename OutputType>
2881 template <
typename OutputType>
2891 Assembly::feADGradPhi<RealVectorValue>(FEType type)
const 2893 return _ad_vector_grad_phi_data[type];
2898 Assembly::feADGradPhiFace<RealVectorValue>(FEType type)
const 2900 return _ad_vector_grad_phi_data_face[type];
2905 Assembly::fePhi<VectorValue<Real>>(FEType type)
const;
2909 Assembly::feGradPhi<VectorValue<Real>>(FEType type)
const;
2913 Assembly::feSecondPhi<VectorValue<Real>>(FEType type)
const;
2917 Assembly::fePhiLower<VectorValue<Real>>(FEType type)
const;
2921 Assembly::feDualPhiLower<VectorValue<Real>>(FEType type)
const;
2925 Assembly::feGradPhiLower<VectorValue<Real>>(FEType type)
const;
2929 Assembly::feGradDualPhiLower<VectorValue<Real>>(FEType type)
const;
2933 Assembly::fePhiFace<VectorValue<Real>>(FEType type)
const;
2937 Assembly::feGradPhiFace<VectorValue<Real>>(FEType type)
const;
2941 Assembly::feSecondPhiFace<VectorValue<Real>>(FEType type)
const;
2945 Assembly::fePhiNeighbor<VectorValue<Real>>(FEType type)
const;
2949 Assembly::feGradPhiNeighbor<VectorValue<Real>>(FEType type)
const;
2953 Assembly::feSecondPhiNeighbor<VectorValue<Real>>(FEType type)
const;
2957 Assembly::fePhiFaceNeighbor<VectorValue<Real>>(FEType type)
const;
2961 Assembly::feGradPhiFaceNeighbor<VectorValue<Real>>(FEType type)
const;
2965 Assembly::feSecondPhiFaceNeighbor<VectorValue<Real>>(FEType type)
const;
2969 Assembly::feCurlPhi<VectorValue<Real>>(FEType type)
const;
2973 Assembly::feCurlPhiFace<VectorValue<Real>>(FEType type)
const;
2977 Assembly::feCurlPhiNeighbor<VectorValue<Real>>(FEType type)
const;
2981 Assembly::feCurlPhiFaceNeighbor<VectorValue<Real>>(FEType type)
const;
2985 Assembly::feDivPhi<VectorValue<Real>>(FEType type)
const;
2989 Assembly::feDivPhiFace<VectorValue<Real>>(FEType type)
const;
2993 Assembly::feDivPhiNeighbor<VectorValue<Real>>(FEType type)
const;
2997 Assembly::feDivPhiFaceNeighbor<VectorValue<Real>>(FEType type)
const;
3003 return _ad_vector_grad_phi_data.at(v.feType());
3006 template <
typename Res
iduals,
typename Indices>
3009 const Indices & input_row_indices,
3010 const Real scaling_factor,
3012 const std::set<TagID> & vector_tags)
3014 mooseAssert(residuals.size() == input_row_indices.size(),
3015 "The number of residuals should match the number of dof indices");
3016 mooseAssert(residuals.size() >= 1,
"Why you calling me with no residuals?");
3021 if (residuals.size() == 1)
3026 residuals, input_row_indices, scaling_factor,
LocalDataKey{}, vector_tags);
3031 _row_indices.assign(input_row_indices.begin(), input_row_indices.end());
3046 template <
typename Res
iduals,
typename Indices>
3049 const Indices & row_indices,
3050 const Real scaling_factor,
3052 const std::set<TagID> & vector_tags)
3054 mooseAssert(residuals.size() == row_indices.size(),
3055 "The number of residuals should match the number of dof indices");
3056 mooseAssert(residuals.size() >= 1,
"Why you calling me with no residuals?");
3064 template <
typename Res
iduals,
typename Indices>
3067 const Indices & input_row_indices,
3068 const Real scaling_factor,
3070 const std::set<TagID> & matrix_tags)
3075 if (residuals.size() == 1)
3080 residuals, input_row_indices, scaling_factor,
LocalDataKey{}, matrix_tags);
3084 const auto & compare_dofs = residuals[0].derivatives().nude_indices();
3086 auto compare_dofs_set = std::set<dof_id_type>(compare_dofs.begin(), compare_dofs.end());
3088 for (
auto resid_it = residuals.begin() + 1; resid_it != residuals.end(); ++resid_it)
3090 auto current_dofs_set = std::set<dof_id_type>(resid_it->derivatives().nude_indices().begin(),
3091 resid_it->derivatives().nude_indices().end());
3092 mooseAssert(compare_dofs_set == current_dofs_set,
3093 "We're going to see whether the dof sets are the same. IIRC the degree of freedom " 3094 "dependence (as indicated by the dof index set held by the ADReal) has to be the " 3095 "same for every residual passed to this method otherwise constrain_element_matrix " 3107 _row_indices.assign(input_row_indices.begin(), input_row_indices.end());
3112 const auto & sparse_derivatives = residuals[i].derivatives();
3125 template <
typename Res
iduals,
typename Indices>
3128 const Indices & row_indices,
3129 const Real scaling_factor,
3131 const std::set<TagID> & matrix_tags)
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?");
3142 const auto row_index = row_indices[i];
3144 const auto & sparse_derivatives = residuals[i].derivatives();
3145 const auto & column_indices = sparse_derivatives.nude_indices();
3146 const auto & raw_derivatives = sparse_derivatives.nude_data();
3148 for (std::size_t j = 0; j < column_indices.size(); ++j)
3150 row_index, column_indices[j], raw_derivatives[j] * scaling_factor, {}, matrix_tags);
3170 std::vector<std::pair<unsigned int, unsigned short>> && disp_numbers_and_directions)
const Real & neighborVolume()
Returns the reference to the current neighbor volume.
VariablePhiSecond _second_phi_face
const Elem *const & elem() const
Return the current element.
VariablePhiSecond _second_phi_face_neighbor
const VectorVariablePhiValue & phi(const MooseVariableField< RealVectorValue > &) const
const FEVectorBase *const & getVectorFEFace(FEType type, unsigned int dim) const
GetVector a reference to a pointer that will contain the current "face" FE.
MooseArray< DualReal > _ad_JxW
void copyShapes(MooseVariableField< T > &v)
const FEVectorBase *const & getVectorFE(FEType type, unsigned int dim) const
Get a reference to a pointer that will contain the current volume FEVector.
std::map< unsigned int, std::map< FEType, FEBase * > > _fe_face
types of finite elements
bool _need_neighbor_elem_volume
true is apps need to compute neighbor element volume
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 ...
const unsigned int & neighborSide() const
Returns the current neighboring side.
VectorVariablePhiSecond & secondPhi(const MooseVariableField< RealVectorValue > &)
ArbitraryQuadrature * _current_qrule_arbitrary
The current arbitrary quadrature rule used within the element interior.
std::map< FEType, FEBase * > _current_fe
The "volume" fe object that matches the current elem.
MooseArray< Real > _curvatures
VectorVariablePhiValue _phi
std::vector< std::vector< dof_id_type > > _cached_residual_rows
Where the cached values should go (the first vector is for TIME vs NONTIME)
std::vector< std::vector< dof_id_type > > _cached_jacobian_rows
Row where the corresponding cached value should go.
void computeGradPhiAD(const Elem *elem, unsigned int n_qp, ADTemplateVariablePhiGradient< OutputType > &grad_phi, FEGenericBase< OutputType > *fe)
compute gradient of phi possibly with derivative information with respect to nonlinear displacement v...
unsigned int _max_cached_residuals
std::map< FEType, ADTemplateVariablePhiGradient< Real > > _ad_grad_phi_data_face
MooseArray< VectorValue< DualReal > > _ad_q_points_face
const OutputTools< OutputType >::VariablePhiCurl & feCurlPhi(FEType type) const
std::vector< DualReal > _ad_detadz_map
QBase * _current_qrule_lower
quadrature rule used on lower dimensional elements.
bool _user_added_fe_lower_of_helper_type
MooseArray< Point > _current_physical_points
This will be filled up with the physical points passed into reinitAtPhysical() if it is called...
std::vector< DualReal > _ad_dxidy_map
VariablePhiSecond & secondPhiNeighbor(const MooseVariableField< RealEigenVector > &)
const VariablePhiGradient & gradPhiFaceNeighbor(const MooseVariableField< Real > &) const
std::vector< std::unique_ptr< FEBase > > _unique_fe_lower_helper
MooseArray< VectorValue< DualReal > > _ad_normals
const MooseArray< ADPoint > & adQPointsFace() const
void setResidualBlock(NumericVector< Number > &residual, DenseVector< Number > &res_block, const std::vector< dof_id_type > &dof_indices, const std::vector< Real > &scaling_factor, bool is_nodal)
Set a local residual block to a global residual vector with proper scaling.
std::vector< std::pair< MooseVariableFieldBase *, MooseVariableFieldBase * > > & couplingEntries()
void buildNeighborFE(FEType type) const
Build FEs for a neighbor with a type.
const VariablePhiSecond & secondPhi() const
void setMortarQRule(Order order)
Specifies a custom qrule for integration on mortar segment mesh.
std::map< unsigned int, std::map< FEType, FEVectorBase * > > _vector_fe
Each dimension's actual vector fe objects indexed on type.
typename OutputTools< typename Moose::ADType< T >::type >::VariablePhiGradient ADTemplateVariablePhiGradient
void buildVectorLowerDFE(FEType type) const
Build Vector FEs for a lower dimensional element with a type.
std::vector< VectorValue< DualReal > > _ad_d2xyzdxi2_map
MooseArray< Real > _coord_neighbor
The current coordinate transformation coefficients.
const FEBase *const & getFENeighbor(FEType type, unsigned int dim) const
Get a reference to a pointer that will contain the current 'neighbor' FE.
void buildFE(FEType type) const
Build FEs with a type.
T * qruleFaceHelper(const Elem *elem, unsigned int side, std::function< T *(QRules &)> rule_fn)
const bool & _computing_residual
Whether we are currently computing the residual.
QBase * _qrule_msm
A qrule object for working on mortar segement elements.
QBase * _current_qrule
The current current quadrature rule being used (could be either volumetric or arbitrary - for dirac k...
std::vector< std::vector< std::vector< DenseMatrix< Number > > > > _sub_Kle
dlower/dsecondary (or dlower/delement)
VectorVariablePhiGradient & gradPhiFace(const MooseVariableField< RealVectorValue > &)
void setCurrentBoundaryID(BoundaryID i)
set the current boundary ID
void cacheResidualLower(GlobalDataKey, const std::vector< VectorTag > &tags)
Takes the values that are currently in _sub_Rl and appends them to the cached values.
const std::vector< std::pair< MooseVariableFieldBase *, MooseVariableScalar * > > & fieldScalarCouplingEntries() const
const OutputTools< OutputType >::VariablePhiValue & fePhi(FEType type) const
MooseArray< DualReal > _ad_JxW_face
Keeps track of stuff related to assembling.
Assembly(SystemBase &sys, THREAD_ID tid)
std::map< FEType, std::unique_ptr< FEShapeData > > _fe_shape_data
Shape function values, gradients, second derivatives for each FE type.
Class for stuff related to variables.
const MooseArray< ADReal > & adJxW() const
const ADTemplateVariablePhiGradient< OutputType > & feADGradPhiFace(FEType type) const
void buildLowerDDualFE(FEType type) const
VariablePhiGradient & gradPhiFace(const MooseVariableField< RealEigenVector > &)
void addJacobianBlockNonlocal(SparseMatrix< Number > &jacobian, unsigned int ivar, unsigned int jvar, const DofMap &dof_map, const std::vector< dof_id_type > &idof_indices, const std::vector< dof_id_type > &jdof_indices, GlobalDataKey, TagID tag)
Adds non-local element matrix for ivar rows and jvar columns to the global Jacobian matrix...
VectorVariablePhiValue _vector_phi
MooseArray< Real > _current_JxW_neighbor
The current transformed jacobian weights on a neighbor's face.
std::shared_ptr< XFEMInterface > _xfem
The XFEM controller.
void reinitNeighborLowerDElem(const Elem *elem)
reinitialize a neighboring lower dimensional element
void setCurrentLowerDElem(const Elem *const lower_d_elem)
Set the current lower dimensional element.
const VectorVariablePhiDivergence & divPhiNeighbor(const MooseVariableField< RealVectorValue > &) const
void prepareJacobianBlock()
Sizes and zeroes the Jacobian blocks used for the current element.
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...
VariablePhiSecond & secondPhiFace(const MooseVariableField< Real > &)
VectorValue< Real > RealVectorValue
VariablePhiSecond & secondPhi(const MooseVariableField< Real > &)
std::vector< DualReal > _ad_dzetady_map
std::vector< std::vector< std::vector< DenseMatrix< Number > > > > _sub_Kel
dsecondary/dlower (or delement/dlower)
MooseArray< Real > _coord
The current coordinate transformation coefficients.
const OutputTools< OutputType >::VariablePhiValue & fePhiLower(FEType type) const
VariablePhiDivergence _div_phi
MooseArray< VectorValue< DualReal > > _ad_q_points
std::unique_ptr< QBase > vol
volume/elem (meshdim) quadrature rule
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. ...
void reinitFE(const Elem *elem)
Just an internal helper function to reinit the volume FE objects.
const Real & neighborLowerDElemVolume() 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 arr...
VariablePhiGradient & gradPhiFaceNeighbor(const MooseVariableField< RealEigenVector > &)
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.
const MooseArray< Point > & physicalPoints() const
The current points in physical space where we have reinited through reinitAtPhysical() ...
VectorVariablePhiGradient & gradPhiNeighbor(const MooseVariableField< RealVectorValue > &)
void init(const CouplingMatrix *cm)
Initialize the Assembly object and set the CouplingMatrix for use throughout.
VariablePhiGradient _grad_phi
std::map< unsigned int, FEBase * > _holder_fe_neighbor_helper
Each dimension's helper objects.
const VectorVariablePhiSecond & secondPhi(const MooseVariableField< RealVectorValue > &) const
std::unique_ptr< FEBase > _fe_msm
A FE object for working on mortar segement elements.
std::map< FEType, std::unique_ptr< FEShapeData > > _fe_shape_data_face_neighbor
const VectorVariablePhiValue & phiNeighbor(const MooseVariableField< RealVectorValue > &) const
VectorVariablePhiValue & phiFace(const MooseVariableField< RealVectorValue > &)
std::vector< std::pair< MooseVariableFieldBase *, MooseVariableFieldBase * > > & nonlocalCouplingEntries()
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 ...
VariablePhiSecond _second_phi_neighbor
void setXFEM(std::shared_ptr< XFEMInterface > xfem)
Set the pointer to the XFEM controller object.
std::vector< DualReal > _ad_dzetadz_map
const MooseArray< ADPoint > & adQPoints() const
void reinitAtPhysical(const Elem *elem, const std::vector< Point > &physical_points)
Reinitialize the assembly data at specific physical point in the given element.
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)
bool _current_elem_volume_computed
Boolean to indicate whether current element volumes has been computed.
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...
MooseVariableFE< Real > MooseVariable
const VectorVariablePhiDivergence & divPhi(const MooseVariableField< RealVectorValue > &) const
VectorVariablePhiGradient _vector_grad_phi_neighbor
std::map< FEType, bool > _need_div
const MooseArray< Point > & qPointsFaceNeighbor() const
Returns the reference to the current quadrature points being used on the neighbor face...
std::vector< std::unique_ptr< FEBase > > _unique_fe_neighbor_helper
std::vector< std::vector< std::vector< DenseMatrix< Number > > > > _sub_Kll
dlower/dlower
VectorVariablePhiValue & phiFaceNeighbor(const MooseVariableField< RealVectorValue > &)
VectorVariablePhiCurl & curlPhi(const MooseVariableField< RealVectorValue > &)
bool _user_added_fe_face_neighbor_of_helper_type
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...
bool _have_p_refinement
Whether we have ever conducted p-refinement.
Real _current_neighbor_volume
Volume of the current neighbor.
void resize(const unsigned int n)
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...
ArbitraryQuadrature * qruleArbitraryFace(const Elem *elem, unsigned int side)
std::map< FEType, FEBase * > _current_fe_face
The "face" fe object that matches the current elem.
VectorVariablePhiGradient & gradPhi(const MooseVariableField< RealVectorValue > &)
const VectorVariablePhiCurl & curlPhi(const MooseVariableField< RealVectorValue > &) const
std::vector< Point > _current_neighbor_ref_points
The current reference points on the neighbor element.
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 ...
std::vector< std::vector< std::vector< DenseMatrix< Number > > > > _sub_Kln
dlower/dprimary (or dlower/dneighbor)
MooseVariableFE< RealVectorValue > VectorMooseVariable
const Elem * _current_neighbor_elem
The current neighbor "element".
void addJacobianNonlocal(GlobalDataKey)
Adds non-local Jacobian to the global Jacobian matrices.
VectorVariablePhiGradient & gradPhiFaceNeighbor(const MooseVariableField< RealVectorValue > &)
VariablePhiValue & phiFace(const MooseVariableField< Real > &)
std::vector< std::vector< DenseVector< Number > > > _sub_Rn
const OutputTools< OutputType >::VariablePhiValue & feDualPhiLower(FEType type) const
const VariablePhiValue & phi() const
std::map< FEType, std::unique_ptr< FEShapeData > > _fe_shape_data_neighbor
std::map< unsigned int, FEBase * > _holder_fe_face_neighbor_helper
std::unique_ptr< QBase > fv_face
finite volume face/flux quadrature rule (meshdim-1)
const VariablePhiGradient & gradPhi() const
MooseArray< Real > _current_JxW_face
The current transformed jacobian weights on a face.
void modifyWeightsDueToXFEM(const Elem *elem)
Update the integration weights for XFEM partial elements.
DenseMatrix< Number > _tmp_Ke
auxiliary matrix for scaling jacobians (optimization to avoid expensive construction/destruction) ...
const Elem * _current_elem
The current "element" we are currently on.
VectorVariablePhiCurl _vector_curl_phi_neighbor
VectorVariablePhiCurl & curlPhiNeighbor(const MooseVariableField< RealVectorValue > &)
const VariablePhiSecond & secondPhiNeighbor(const MooseVariableField< Real > &) const
const FEBase *const & getFEFace(FEType type, unsigned int dim) const
Get a reference to a pointer that will contain the current "face" FE.
THREAD_ID _tid
Thread number (id)
void reinitFEFaceNeighbor(const Elem *neighbor, const std::vector< Point > &reference_points)
static constexpr std::size_t dim
This is the dimension of all vector and tensor datastructures used in MOOSE.
VectorVariablePhiGradient _vector_grad_phi
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.
std::vector< std::unique_ptr< FEBase > > _unique_fe_face_helper
std::vector< std::vector< std::vector< unsigned char > > > _jacobian_block_nonlocal_used
std::vector< std::pair< MooseVariableScalar *, MooseVariableFieldBase * > > _cm_sf_entry
Entries in the coupling matrix for scalar variables vs field variables.
VectorVariablePhiValue _vector_phi_neighbor
void resizeADMappingObjects(unsigned int n_qp, unsigned int dim)
resize any objects that contribute to automatic differentiation-related mapping calculations ...
OutputTools< Real >::VariablePhiValue VariablePhiValue
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...
ElemSideBuilder _current_neighbor_side_elem_builder
In place side element builder for _current_neighbor_side_elem.
VariablePhiValue & phi(const MooseVariableField< Real > &)
std::map< unsigned int, std::map< FEType, FEVectorBase * > > _vector_fe_face_neighbor
std::map< FEType, bool > _need_second_derivative
const VariablePhiValue & phiFaceNeighbor(const MooseVariableField< Real > &) const
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...
Real _current_elem_volume
Volume of the current element.
OutputTools< RealVectorValue >::VariablePhiGradient VectorVariablePhiGradient
std::map< FEType, FEBase * > _current_fe_face_neighbor
The "neighbor face" fe object that matches the current elem.
const MooseArray< ADReal > & adCurvatures() const
This class provides an interface for common operations on field variables of both FE and FV types wit...
const MooseArray< Point > & qPoints() const
Returns the reference to the quadrature points.
std::map< FEType, FEVectorBase * > _current_vector_fe_face
The "face" vector fe object that matches the current elem.
QBase *const & writeableQRuleNeighbor()
Returns the reference to the current quadrature being used on a current neighbor. ...
std::vector< std::unique_ptr< FEBase > > _unique_fe_helper
Containers for holding unique FE helper types if we are doing p-refinement.
std::vector< DualReal > _ad_dzetadx_map
void processLocalResidual(DenseVector< Number > &res_block, std::vector< dof_id_type > &dof_indices, const std::vector< Real > &scaling_factor, bool is_nodal)
Appling scaling, constraints to the local residual block and populate the full DoF indices for array ...
const FEType _helper_type
The finite element type of the FE helper classes.
const Elem *const & msmElem() const
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...
DenseMatrix< Number > & jacobianBlock(unsigned int ivar, unsigned int jvar, LocalDataKey, TagID tag)
Get local Jacobian block for a pair of variables and a tag.
The following methods are specializations for using the libMesh::Parallel::packed_range_* routines fo...
void addJacobianScalar(GlobalDataKey)
Add Jacobians for pairs of scalar variables into the global Jacobian matrices.
const bool & _computing_residual_and_jacobian
Whether we are currently computing the residual and Jacobian.
std::vector< std::vector< std::vector< DenseMatrix< Number > > > > _sub_Knn
jacobian contributions from the neighbor <Tag, ivar, jvar>
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...
const ADTemplateVariablePhiGradient< T > & adGradPhi(const MooseVariableFE< T > &v) const
Base class for a system (of equations)
const std::vector< Eigen::Map< RealDIMValue > > & mappedNormals() const
const QBase * attachQRuleElem(unsigned int dim, FEBase &fe)
Attaches the current elem/volume quadrature rule to the given fe.
const VariablePhiValue & phiNeighbor(const MooseVariableField< Real > &) const
void setVolumeQRule(QBase *qrule, unsigned int dim)
Set the qrule to be used for volume integration.
FEGenericBase< RealGradient > FEVectorBase
VectorVariablePhiSecond & secondPhiFaceNeighbor(const MooseVariableField< RealVectorValue > &)
unsigned int numExtraElemIntegers() const
Number of extra element integers Assembly tracked.
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...
std::vector< std::vector< Real > > _cached_jacobian_values
Values cached by calling cacheJacobian()
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...
const OutputTools< OutputType >::VariablePhiSecond & feSecondPhiFaceNeighbor(FEType type) const
std::vector< std::pair< MooseVariableFieldBase *, MooseVariableFieldBase * > > _cm_ff_entry
Entries in the coupling matrix for field variables.
void addJacobianNeighborLowerD(GlobalDataKey)
Add all portions of the Jacobian except PrimaryPrimary, e.g.
const MooseArray< Real > & mortarCoordTransformation() const
Returns the reference to the coordinate transformation coefficients on the mortar segment mesh...
std::map< FEType, FEVectorBase * > _current_vector_fe
The "volume" vector fe object that matches the current elem.
VariablePhiGradient & gradPhiNeighbor(const MooseVariableField< RealEigenVector > &)
VariablePhiGradient _grad_phi
VariablePhiSecond & secondPhiNeighbor(const MooseVariableField< Real > &)
DenseVector< Real > getJacobianDiagonal(DenseMatrix< Number > &ke)
Specialization of SubProblem for solving nonlinear equations plus auxiliary equations.
ElemSideBuilder _compute_face_map_side_elem_builder
In place side element builder for computeFaceMap()
const dof_id_type & extraElemID(unsigned int id) const
Returns an integer ID of the current element given the index associated with the integer.
void modifyFaceWeightsDueToXFEM(const Elem *elem, unsigned int side=0)
Update the face integration weights for XFEM partial elements.
const CouplingMatrix * _cm
Coupling matrices.
std::map< FEType, bool > _need_second_derivative_neighbor
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.
const VectorVariablePhiSecond & secondPhiNeighbor(const MooseVariableField< RealVectorValue > &) const
const OutputTools< OutputType >::VariablePhiGradient & feGradPhiFace(FEType type) const
const OutputTools< OutputType >::VariablePhiDivergence & feDivPhiFaceNeighbor(FEType type) const
OutputTools< Real >::VariablePhiSecond VariablePhiSecond
const FEType & feType() const
Get the type of finite element object.
DenseVector< Number > _tmp_Re
auxiliary vector for scaling residuals (optimization to avoid expensive construction/destruction) ...
unsigned int _mesh_dimension
std::vector< Eigen::Map< RealDIMValue > > _mapped_normals
Mapped normals.
VectorVariablePhiDivergence _vector_div_phi_face
VectorVariablePhiCurl & curlPhiFaceNeighbor(const MooseVariableField< RealVectorValue > &)
void cacheJacobian(GlobalDataKey)
Takes the values that are currently in _sub_Kee and appends them to the cached values.
const OutputTools< OutputType >::VariablePhiDivergence & feDivPhiNeighbor(FEType type) const
void reinit(const Elem *elem)
Reinitialize objects (JxW, q_points, ...) for an elements.
const NumericVector< Real > * _scaling_vector
The map from global index to variable scaling factor.
void assignDisplacements(std::vector< std::pair< unsigned int, unsigned short >> &&disp_numbers_and_directions)
Assign the displacement numbers and directions.
QBase * _current_qrule_volume
The current volumetric quadrature for the element.
void addCachedResiduals(GlobalDataKey, const std::vector< VectorTag > &tags)
Pushes all cached residuals to the global residual vectors associated with each tag.
const DofMap & _dof_map
DOF map.
Data structure for tracking/grouping a set of quadrature rules for a particular dimensionality of mes...
std::vector< DualReal > _ad_dxidx_map
unsigned int _max_cached_jacobians
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.
std::vector< std::vector< std::vector< DenseMatrix< Number > > > > _sub_Ken
jacobian contributions from the element and neighbor <Tag, ivar, jvar>
std::map< FEType, std::unique_ptr< VectorFEShapeData > > _vector_fe_shape_data_dual_lower
const CouplingMatrix & _nonlocal_cm
Nonlinear system to be solved.
VectorVariablePhiValue _vector_phi_face
const VectorVariablePhiSecond & secondPhiFace(const MooseVariableField< RealVectorValue > &) const
std::vector< Point > _temp_reference_points
Temporary work data for reinitAtPhysical()
std::vector< std::pair< MooseVariableScalar *, MooseVariableScalar * > > _cm_ss_entry
Entries in the coupling matrix for scalar variables.
std::vector< std::vector< std::vector< DenseMatrix< Number > > > > _sub_Kne
jacobian contributions from the neighbor and element <Tag, ivar, jvar>
const Elem * _current_neighbor_lower_d_elem
The current neighboring lower dimensional element.
OutputTools< RealVectorValue >::VariablePhiDivergence VectorVariablePhiDivergence
unsigned int _current_neighbor_side
The current side of the selected neighboring element (valid only when working with sides) ...
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.
VectorVariablePhiSecond & secondPhiNeighbor(const MooseVariableField< RealVectorValue > &)
void prepareLowerD()
Prepare the Jacobians and residuals for a lower dimensional element.
bool _user_added_fe_neighbor_of_helper_type
QBase *const & writeableQRuleFace()
Returns the reference to the current quadrature being used on a current face.
void buildFaceNeighborFE(FEType type) const
Build FEs for a neighbor face with a type.
std::map< FEType, std::unique_ptr< VectorFEShapeData > > _vector_fe_shape_data_face
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 computeCurrentFaceVolume()
const VectorVariablePhiCurl & curlPhiNeighbor(const MooseVariableField< RealVectorValue > &) const
std::vector< std::vector< DenseVector< Number > > > _sub_Rl
residual contributions for each variable from the lower dimensional element
VariablePhiCurl _curl_phi
This data structure is used to store geometric and variable related metadata about each cell face in ...
QRules & qrules(unsigned int dim)
static const subdomain_id_type invalid_subdomain_id
VectorVariablePhiGradient _vector_grad_phi_face_neighbor
void prepareOffDiagScalar()
VectorVariablePhiSecond _second_phi
const OutputTools< OutputType >::VariablePhiDivergence & feDivPhiFace(FEType type) const
bool needDual() const
Indicates whether dual shape functions are used (computation is now repeated on each element so expen...
Implements a fake quadrature rule where you can specify the locations (in the reference domain) of th...
void addJacobianCoupledVarPair(const MooseVariableBase &ivar, const MooseVariableBase &jvar)
Adds element matrices for ivar rows and jvar columns to the global Jacobian matrices.
void addJacobianLowerD(GlobalDataKey)
Add portions of the Jacobian of LowerLower, LowerSecondary, and SecondaryLower for boundary condition...
QBase * _current_qrule_neighbor
quadrature rule used on neighbors
std::vector< DualReal > _ad_dxidz_map
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 u...
VectorVariablePhiGradient _grad_phi
ArbitraryQuadrature * _current_qrule_arbitrary_face
The current arbitrary quadrature rule used on the element face.
const MooseArray< ADReal > & adCoordTransformation() const
Returns the reference to the AD version of the coordinate transformation coefficients.
const OutputTools< OutputType >::VariablePhiCurl & feCurlPhiFaceNeighbor(FEType type) const
void modifyArbitraryWeights(const std::vector< Real > &weights)
Modify the weights when using the arbitrary quadrature rule.
FEBase * _current_fe_face_helper
helper object for transforming coordinates
std::vector< std::pair< MooseVariableFieldBase *, MooseVariableScalar * > > _cm_fs_entry
Entries in the coupling matrix for field variables vs scalar variables.
const std::vector< Real > * _JxW_msm
A JxW for working on mortar segement elements.
std::unique_ptr< QBase > face
area/face (meshdim-1) quadrature rule
dof_id_type numeric_index_type
std::map< FEType, ADTemplateVariablePhiGradient< Real > > _ad_grad_phi_data
std::unordered_map< SubdomainID, std::vector< QRules > > _qrules
Holds quadrature rules for each dimension.
const MooseArray< Point > & normals() const
Returns the array of normals for quadrature points on a current side.
MooseVariableFE< RealEigenVector > ArrayMooseVariable
const VectorVariablePhiGradient & gradPhi(const MooseVariableField< RealVectorValue > &) const
const QBase *const & qRuleNeighbor() const
Returns the reference to the current quadrature being used on a current neighbor. ...
void prepareResidual()
Sizes and zeroes the residual for the current element.
VectorVariablePhiCurl _curl_phi
std::map< FEType, FEBase * > _current_fe_neighbor
The "neighbor" fe object that matches the current elem.
const ADTemplateVariablePhiGradient< OutputType > & feADGradPhi(FEType type) const
Real elementVolume(const Elem *elem) const
On-demand computation of volume element accounting for RZ/RSpherical.
VariablePhiSecond & secondPhiFaceNeighbor(const MooseVariableField< Real > &)
void cacheJacobianNeighbor(GlobalDataKey)
Takes the values that are currently in the neighbor Dense Matrices and appends them to the cached val...
SubdomainID _current_neighbor_subdomain_id
The current neighbor subdomain ID.
QBase *const & writeableQRule()
Returns the reference to the current quadrature being used.
VectorVariablePhiValue _vector_phi_face_neighbor
VariablePhiSecond & secondPhi(const MooseVariableField< RealEigenVector > &)
VariablePhiValue & phiFaceNeighbor(const MooseVariableField< Real > &)
const VectorVariablePhiCurl & curlPhiFace(const MooseVariableField< RealVectorValue > &) const
std::vector< std::vector< DenseVector< Number > > > _sub_Re
VectorVariablePhiSecond & secondPhiFace(const MooseVariableField< RealVectorValue > &)
OutputTools< RealVectorValue >::VariablePhiSecond VectorVariablePhiSecond
boundary_id_type BoundaryID
void reinitNeighbor(const Elem *neighbor, const std::vector< Point > &reference_points)
Reinitializes the neighbor side using reference coordinates.
A NodeFaceConstraint is used when you need to create constraints between two surfaces in a mesh...
const MooseArray< Real > & coordTransformation() const
Returns the reference to the coordinate transformation coefficients.
const OutputTools< OutputType >::VariablePhiCurl & feCurlPhiNeighbor(FEType type) const
const Real & lowerDElemVolume() const
VectorVariablePhiDivergence _vector_div_phi_neighbor
QRules & qrules(unsigned int dim, SubdomainID block)
This is a helper function for accessing quadrature rules for a particular dimensionality of element...
std::vector< std::vector< std::vector< unsigned char > > > _jacobian_block_used
Flag that indicates if the jacobian block was used.
void setFaceQRule(QBase *qrule, unsigned int dim)
Set the qrule to be used for face integration.
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.
VariablePhiGradient & gradPhiFace(const MooseVariableField< Real > &)
std::vector< DualReal > _ad_jac
MooseMesh wraps a libMesh::Mesh object and enhances its capabilities by caching additional data and s...
const VariablePhiGradient & gradPhi(const MooseVariableField< Real > &) const
void buildFaceFE(FEType type) const
Build FEs for a face with a type.
const QBase * attachQRuleFace(unsigned int dim, FEBase &fe)
Attaches the current face/area quadrature rule to the given fe.
std::map< unsigned int, std::map< FEType, FEBase * > > _fe_neighbor
types of finite elements
DenseVector< Number > & residualBlockLower(unsigned int var_num, LocalDataKey, TagID tag_id)
Get residual block for lower.
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 ...
MooseArray< std::vector< Point > > _current_tangents
The current tangent vectors at the quadrature points.
bool _calculate_curvatures
VariablePhiGradient _grad_phi_face_neighbor
const std::vector< VectorTag > & _residual_vector_tags
The residual vector tags that Assembly could possibly contribute to.
std::map< FEType, FEVectorBase * > _current_vector_fe_face_neighbor
The "neighbor face" vector fe object that matches the current elem.
const OutputTools< OutputType >::VariablePhiCurl & feCurlPhiFace(FEType type) const
std::vector< dof_id_type > _neighbor_extra_elem_ids
Extra element IDs of neighbor.
MooseArray< Real > _current_JxW
The current list of transformed jacobian weights.
void havePRefinement(const std::vector< FEFamily > &disable_p_refinement_for_families)
Indicate that we have p-refinement.
std::vector< std::pair< unsigned int, unsigned short > > _disp_numbers_and_directions
Container of displacement numbers and directions.
VectorVariablePhiDivergence & divPhi(const MooseVariableField< RealVectorValue > &)
std::vector< dof_id_type > _temp_dof_indices
Temporary work vector to keep from reallocating it.
OutputTools< Real >::VariablePhiCurl VariablePhiCurl
const QBase *const & qRule() const
Returns the reference to the current quadrature being used.
std::vector< std::vector< std::vector< DenseMatrix< Number > > > > _sub_Kee
std::map< FEType, std::unique_ptr< VectorFEShapeData > > _vector_fe_shape_data_lower
VectorVariablePhiValue & phiNeighbor(const MooseVariableField< RealVectorValue > &)
const VariablePhiSecond & secondPhiFace(const MooseVariableField< Real > &) const
std::map< FEType, ADTemplateVariablePhiGradient< RealVectorValue > > _ad_vector_grad_phi_data
VariablePhiGradient _grad_phi_neighbor
const Real & elemVolume()
Returns the reference to the current element volume.
ArbitraryQuadrature * _current_qface_arbitrary
The current arbitrary quadrature rule used on element faces.
std::map< unsigned int, std::map< FEType, FEVectorBase * > > _vector_fe_face
types of vector finite elements
VariablePhiValue _phi_face
VectorVariablePhiSecond _vector_second_phi
subdomain_id_type SubdomainID
const std::vector< std::pair< MooseVariableFieldBase *, MooseVariableFieldBase * > > & couplingEntries() const
const OutputTools< OutputType >::VariablePhiGradient & feGradPhi(FEType type) const
Eigen::Matrix< Real, Eigen::Dynamic, Eigen::Dynamic > RealEigenMatrix
QBase * qruleFace(const Elem *elem, unsigned int side)
This is an abstraction over the internal qrules function.
bool _calculate_ad_coord
Whether to calculate coord with AD.
std::map< FEType, std::unique_ptr< FEShapeData > > _fe_shape_data_lower
const Elem * _current_lower_d_elem
The current lower dimensional element.
GlobalDataKey(const GlobalDataKey &)
void addResidualBlock(NumericVector< Number > &residual, DenseVector< Number > &res_block, const std::vector< dof_id_type > &dof_indices, const std::vector< Real > &scaling_factor, bool is_nodal)
Add a local residual block to a global residual vector with proper scaling.
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...
void addJacobianNeighborTags(SparseMatrix< Number > &jacobian, unsigned int ivar, unsigned int jvar, const DofMap &dof_map, std::vector< dof_id_type > &dof_indices, std::vector< dof_id_type > &neighbor_dof_indices, GlobalDataKey, const std::set< TagID > &tags)
Adds three neighboring element matrices for ivar rows and jvar columns to the global Jacobian matrix...
std::vector< VectorValue< DualReal > > _ad_dxyzdeta_map
const VariablePhiValue & phiFace() const
bool computingResidualAndJacobian() const
std::map< unsigned int, std::map< FEType, FEBase * > > _fe_lower
FE objects for lower dimensional elements.
const VectorVariablePhiCurl & curlPhiFaceNeighbor(const MooseVariableField< RealVectorValue > &) const
FEGenericBase< Real > FEBase
void cacheResiduals(const Residuals &residuals, const Indices &row_indices, Real scaling_factor, LocalDataKey, const std::set< TagID > &vector_tags)
Process the supplied residual values.
const OutputTools< OutputType >::VariablePhiGradient & feGradPhiLower(FEType type) const
void addJacobianBlockNonlocalTags(SparseMatrix< Number > &jacobian, unsigned int ivar, unsigned int jvar, const DofMap &dof_map, const std::vector< dof_id_type > &idof_indices, const std::vector< dof_id_type > &jdof_indices, GlobalDataKey, const std::set< TagID > &tags)
Adds non-local element matrix for ivar rows and jvar columns to the global Jacobian matrix...
VariablePhiValue _phi_face_neighbor
OutputTools< Real >::VariablePhiDivergence VariablePhiDivergence
Real _current_lower_d_elem_volume
The current lower dimensional element volume.
const OutputTools< OutputType >::VariablePhiValue & fePhiNeighbor(FEType type) const
std::map< unsigned int, std::map< FEType, FEBase * > > _fe
Each dimension's actual fe objects indexed on type.
const VariablePhiSecond & secondPhi(const MooseVariableField< Real > &) const
VariablePhiValue _phi_neighbor
const Node *const & nodeNeighbor() const
Returns the reference to the neighboring node.
const MooseArray< Real > & JxW() const
Returns the reference to the transformed jacobian weights.
void reinitMortarElem(const Elem *elem)
reinitialize a mortar segment mesh element in order to get a proper JxW
const OutputTools< OutputType >::VariablePhiGradient & feGradPhiFaceNeighbor(FEType type) const
Real _current_side_volume
Volume of the current side element.
VectorVariablePhiCurl _vector_curl_phi
std::vector< std::vector< Real > > _cached_residual_values
Values cached by calling cacheResidual() (the first vector is for TIME vs NONTIME) ...
void buildVectorFE(FEType type) const
Build Vector FEs with a type.
VectorVariablePhiCurl _vector_curl_phi_face_neighbor
MooseArray< DualReal > _ad_curvatures
void reinitFVFace(const FaceInfo &fi)
std::map< unsigned int, std::map< FEType, FEVectorBase * > > _vector_fe_lower
Vector FE objects for lower dimensional elements.
const MooseArray< Real > & JxWFace() const
Returns the reference to the transformed jacobian weights on a current face.
const MooseArray< Real > & JxWNeighbor() const
Returns the reference to the transformed jacobian weights on a current face.
std::vector< VectorValue< DualReal > > _ad_d2xyzdxideta_map
const Node * _current_node
The current node we are working with.
bool _building_helpers
Whether we are currently building the FE classes for the helpers.
This is the XFEMInterface class.
const MooseArray< MooseADWrapper< Point, is_ad > > & genericQPoints() const
OutputTools< Real >::VariablePhiGradient VariablePhiGradient
std::map< FEType, std::unique_ptr< VectorFEShapeData > > _vector_fe_shape_data_face_neighbor
void addJacobian(GlobalDataKey)
Adds all local Jacobian to the global Jacobian matrices.
MooseArray< Point > _current_normals
The current Normal vectors at the quadrature points.
void buildVectorFaceFE(FEType type) const
Build Vector FEs for a face with a type.
const QBase *const & qRuleFace() const
Returns the reference to the current quadrature being used on a current face.
const SubdomainID ANY_BLOCK_ID
void setCurrentSubdomainID(SubdomainID i)
set the current subdomain ID
const std::vector< std::pair< MooseVariableScalar *, MooseVariableFieldBase * > > & scalarFieldCouplingEntries() const
const MooseArray< ADReal > & adJxWFace() const
const VariablePhiGradient & gradPhiNeighbor(const MooseVariableField< Real > &) const
VectorVariablePhiGradient _vector_grad_phi_face
VariablePhiValue & phiNeighbor(const MooseVariableField< RealEigenVector > &)
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
const VectorVariablePhiDivergence & divPhiFace(const MooseVariableField< RealVectorValue > &) const
void hasScalingVector()
signals this object that a vector containing variable scaling factors should be used when doing resid...
Generic class for solving transient nonlinear problems.
const VectorVariablePhiDivergence & divPhiFaceNeighbor(const MooseVariableField< RealVectorValue > &) const
VariablePhiGradient & gradPhi(const MooseVariableField< Real > &)
OutputTools< RealVectorValue >::VariablePhiValue VectorVariablePhiValue
const OutputTools< OutputType >::VariablePhiDivergence & feDivPhi(FEType type) const
void setNeighborQRule(QBase *qrule, unsigned int dim)
Set the qrule to be used for neighbor integration.
std::map< FEType, std::unique_ptr< FEShapeData > > _fe_shape_data_dual_lower
void zeroCachedJacobian(GlobalDataKey)
Zero out previously-cached Jacobian rows.
std::vector< VectorValue< DualReal > > _ad_dxyzdzeta_map
void setCoordinateTransformation(const QBase *qrule, const Points &q_points, Coords &coord, SubdomainID sub_id)
const VectorVariablePhiGradient & gradPhiNeighbor(const MooseVariableField< RealVectorValue > &) const
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 p...
bool computingResidual() const
void activateDual()
Indicates that dual shape functions are used for mortar constraint.
void prepareVariableNonlocal(MooseVariableFieldBase *var)
std::map< FEType, std::unique_ptr< FEShapeData > > _fe_shape_data_face
std::map< FEType, std::unique_ptr< VectorFEShapeData > > _vector_fe_shape_data
Shape function values, gradients, second derivatives for each vector FE type.
const VariablePhiGradient & gradPhiFace(const MooseVariableField< Real > &) const
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...
MooseArray< Real > _coord_msm
The coordinate transformation coefficients evaluated on the quadrature points of the mortar segment m...
DenseVector< Number > & residualBlockNeighbor(unsigned int var_num, LocalDataKey, TagID tag_id)
Get local neighbor residual block for a variable and a tag.
std::vector< std::vector< std::vector< DenseMatrix< Number > > > > _sub_Keg
VariablePhiValue & phiFaceNeighbor(const MooseVariableField< RealEigenVector > &)
bool _need_lower_d_elem_volume
Whether we need to compute the lower dimensional element volume.
LocalDataKey(const LocalDataKey &)
bool _user_added_fe_face_of_helper_type
const MooseArray< Point > & qPointsFace() const
Returns the reference to the current quadrature being used.
DenseVector< Number > & residualBlock(unsigned int var_num, LocalDataKey, TagID tag_id)
Get local residual block for a variable and a tag.
VectorVariablePhiValue & phi(const MooseVariableField< RealVectorValue > &)
void buildVectorNeighborFE(FEType type) const
Build Vector FEs for a neighbor with a type.
std::unique_ptr< ArbitraryQuadrature > arbitrary_vol
volume/elem (meshdim) custom points quadrature rule
void reinitFENeighbor(const Elem *neighbor, const std::vector< Point > &reference_points)
const VectorVariablePhiValue & phiFace(const MooseVariableField< RealVectorValue > &) const
void initNonlocalCoupling()
Create pair of variables requiring nonlocal jacobian contributions.
const VectorVariablePhiGradient & gradPhiFaceNeighbor(const MooseVariableField< RealVectorValue > &) const
const QBase *const & qRuleMortar() const
Returns a reference to the quadrature rule for the mortar segments.
std::map< unsigned int, FEBase * > _holder_fe_face_helper
Each dimension's helper objects.
const bool & _computing_jacobian
Whether we are currently computing the Jacobian.
void computeCurrentNeighborVolume()
void setLowerQRule(QBase *qrule, unsigned int dim)
Set the qrule to be used for lower dimensional integration.
VariablePhiSecond & secondPhiFace(const MooseVariableField< RealEigenVector > &)
const Elem *const & neighbor() const
Return the neighbor element.
std::map< unsigned int, std::map< FEType, FEVectorBase * > > _vector_fe_neighbor
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 u...
void resize(const unsigned int new_m, const unsigned int new_n)
const OutputTools< OutputType >::VariablePhiValue & fePhiFaceNeighbor(FEType type) const
VariablePhiGradient & gradPhiFaceNeighbor(const MooseVariableField< Real > &)
void cacheJacobianNonlocal(GlobalDataKey)
Takes the values that are currently in _sub_Keg and appends them to the cached values.
Class for scalar variables (they are different).
const VariablePhiValue & phiFace(const MooseVariableField< Real > &) const
VariablePhiValue & phiNeighbor(const MooseVariableField< Real > &)
VectorVariablePhiDivergence & divPhiNeighbor(const MooseVariableField< RealVectorValue > &)
std::vector< std::unique_ptr< FEBase > > _unique_fe_face_neighbor_helper
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...
void helpersRequestData()
request phi, dphi, xyz, JxW, etc.
std::vector< std::pair< MooseVariableFieldBase *, MooseVariableFieldBase * > > _cm_nonlocal_entry
Entries in the coupling matrix for field variables for nonlocal calculations.
void addJacobianOffDiagScalar(unsigned int ivar, GlobalDataKey)
Add Jacobians for a scalar variables with all other field variables into the global Jacobian matrices...
std::vector< dof_id_type > _row_indices
Working vectors to avoid repeated heap allocations when caching residuals/Jacobians that must have li...
VectorVariablePhiSecond _vector_second_phi_face_neighbor
std::vector< DualReal > _ad_detadx_map
void buildLowerDFE(FEType type) const
Build FEs for a lower dimensional element with a type.
unsigned int _current_side
The current side of the selected element (valid only when working with sides)
const VectorVariablePhiSecond & secondPhiFaceNeighbor(const MooseVariableField< RealVectorValue > &) const
void setCachedJacobian(GlobalDataKey)
Sets previously-cached Jacobian values via SparseMatrix::set() calls.
VariablePhiSecond _second_phi
std::map< unsigned int, FEBase * > _holder_fe_helper
Each dimension's helper objects.
const OutputTools< OutputType >::VariablePhiSecond & feSecondPhiNeighbor(FEType type) const
const FEVectorBase *const & getVectorFEFaceNeighbor(FEType type, unsigned int dim) const
GetVector a reference to a pointer that will contain the current "neighbor" FE.
BoundaryID _current_boundary_id
The current boundary ID.
const OutputTools< OutputType >::VariablePhiGradient & feGradDualPhiLower(FEType type) const
const OutputTools< OutputType >::VariablePhiSecond & feSecondPhiFace(FEType type) const
void prepareVariable(MooseVariableFieldBase *var)
Used for preparing the dense residual and jacobian blocks for one particular variable.
const Elem * _current_neighbor_side_elem
The current side element of the ncurrent neighbor element.
DenseMatrix< Number > _element_matrix
A working matrix to avoid repeated heap allocations when caching Jacobians that must have libMesh-lev...
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 referenc...
void copyFaceShapes(MooseVariableField< T > &v)
std::vector< dof_id_type > _extra_elem_ids
Extra element IDs.
void clearCachedQRules()
Set the cached quadrature rules to nullptr.
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...
bool _current_side_volume_computed
Boolean to indicate whether current element side volumes has been computed.
std::map< FEType, ADTemplateVariablePhiGradient< RealVectorValue > > _ad_vector_grad_phi_data_face
std::vector< VectorValue< DualReal > > _ad_d2xyzdeta2_map
std::vector< dof_id_type > _column_indices
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...
std::unique_ptr< ArbitraryQuadrature > arbitrary_face
area/face (meshdim-1) custom points quadrature rule
const Real & sideElemVolume()
Returns the reference to the volume of current side element.
Eigen::Matrix< Real, Eigen::Dynamic, 1 > RealEigenVector
const VariablePhiValue & phi(const MooseVariableField< Real > &) const
const std::vector< Point > & qPointsMortar() const
Returns the reference to the mortar segment element quadrature points.
const SubdomainID & currentSubdomainID() const
Return the current subdomain ID.
void prepareBlock(unsigned int ivar, unsigned jvar, const std::vector< dof_id_type > &dof_indices)
std::map< unsigned int, std::map< FEType, FEBase * > > _fe_face_neighbor
void addJacobianNeighbor(GlobalDataKey)
Add ElementNeighbor, NeighborElement, and NeighborNeighbor portions of the Jacobian for compute objec...
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.
VectorVariablePhiDivergence _div_phi
VectorVariablePhiDivergence & divPhiFace(const MooseVariableField< RealVectorValue > &)
OutputTools< RealVectorValue >::VariablePhiCurl VectorVariablePhiCurl
void cacheJacobianBlock(DenseMatrix< Number > &jac_block, const std::vector< dof_id_type > &idof_indices, const std::vector< dof_id_type > &jdof_indices, Real scaling_factor, LocalDataKey, TagID tag)
Cache a local Jacobian block with the provided rows (idof_indices) and columns (jdof_indices) for eve...
const Moose::CoordinateSystemType & coordSystem()
Get the coordinate system type.
bool _custom_mortar_qrule
Flag specifying whether a custom quadrature rule has been specified for mortar segment mesh...
const unsigned int & side() const
Returns the current side.
const FEBase *const & getFE(FEType type, unsigned int dim) const
Get a reference to a pointer that will contain the current volume FE.
void computeCurrentElemVolume()
void cacheJacobianBlockNonzero(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...
bool computingJacobian() const
Real _current_neighbor_lower_d_elem_volume
The current neighboring lower dimensional element volume.
bool _need_neighbor_lower_d_elem_volume
Whether we need to compute the neighboring lower dimensional element volume.
MooseArray< Point > _current_q_points
The current list of quadrature points.
bool _user_added_fe_of_helper_type
Whether user code requested a FEType the same as our _helper_type.
Moose::CoordinateSystemType _coord_type
The coordinate system.
void cacheJacobianMortar(GlobalDataKey)
Cache all portions of the Jacobian, e.g.
std::unique_ptr< ArbitraryQuadrature > neighbor
area/face (meshdim-1) custom points quadrature rule for DG
void addJacobianBlock(SparseMatrix< Number > &jacobian, unsigned int ivar, unsigned int jvar, const 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 buildVectorFaceNeighborFE(FEType type) const
Build Vector FEs for a neighbor face with a type.
void buildVectorDualLowerDFE(FEType type) const
void bumpVolumeQRuleOrder(Order volume_order, SubdomainID block)
Increases the element/volume quadrature order for the specified mesh block if and only if the current...
const SubdomainID & currentNeighborSubdomainID() const
Return the current subdomain ID.
VectorVariablePhiSecond _vector_second_phi_neighbor
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 k...
Storage for all of the information pretaining to a vector tag.
VectorVariablePhiDivergence & divPhiFaceNeighbor(const MooseVariableField< RealVectorValue > &)
const Node *const & node() const
Returns the reference to the node.
VariablePhiSecond _second_phi
std::vector< std::vector< std::vector< unsigned char > > > _jacobian_block_neighbor_used
Flag that indicates if the jacobian block for neighbor was used.
const OutputTools< OutputType >::VariablePhiGradient & feGradPhiNeighbor(FEType type) const
std::map< unsigned int, FEBase * > _holder_fe_lower_helper
helper object for transforming coordinates for lower dimensional element quadrature points ...
VectorVariablePhiDivergence _vector_div_phi
void setCurrentNeighborSubdomainID(SubdomainID i)
set the current subdomain ID
void computeADFace(const Elem &elem, const unsigned int side)
compute AD things on an element face
std::map< FEType, std::unique_ptr< VectorFEShapeData > > _vector_fe_shape_data_neighbor
std::vector< DualReal > _ad_detady_map
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.
std::vector< std::vector< dof_id_type > > _cached_jacobian_cols
Column where the corresponding cached value should go.
void addCachedJacobian(GlobalDataKey)
Adds the values that have been cached by calling cacheJacobian() and or cacheJacobianNeighbor() to th...
void addJacobianBlockTags(SparseMatrix< Number > &jacobian, unsigned int ivar, unsigned int jvar, const 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...
MooseArray< Point > _current_q_points_face
The current quadrature points on a face.
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, bool is_nodal)
Push a local residual block with proper scaling into cache.
void prepareBlockNonlocal(unsigned int ivar, unsigned jvar, const std::vector< dof_id_type > &idof_indices, const std::vector< dof_id_type > &jdof_indices)
void bumpAllQRuleOrder(Order order, SubdomainID block)
Increases the element/volume and face/area quadrature orders for the specified mesh block if and only...
const Elem *const & lowerDElem() const
Return the lower dimensional element.
const VariablePhiSecond & secondPhiFaceNeighbor(const MooseVariableField< Real > &) const
const Elem * _current_side_elem
The current "element" making up the side we are currently on.
const MooseArray< std::vector< Point > > & tangents() const
Returns the array of tangents for quadrature points on a current side.
bool _block_diagonal_matrix
Will be true if our preconditioning matrix is a block-diagonal matrix. Which means that we can take s...
MooseArray< DualReal > _ad_coord
The AD version of the current coordinate transformation coefficients.
const Elem *const & neighborLowerDElem() const
Return the neighboring lower dimensional element.
const OutputTools< OutputType >::VariablePhiSecond & feSecondPhi(FEType type) const
FEBase * _current_fe_helper
The current helper object for transforming coordinates.
bool _need_JxW_neighbor
Flag to indicate that JxW_neighbor is needed.
const VectorVariablePhiValue & phiFaceNeighbor(const MooseVariableField< RealVectorValue > &) const
std::map< FEType, bool > _need_curl
void copyNeighborShapes(MooseVariableField< T > &v)
void cacheJacobianCoupledVarPair(const MooseVariableBase &ivar, const MooseVariableBase &jvar)
Caches element matrix for ivar rows and jvar columns.
VectorVariablePhiSecond _vector_second_phi_face
const MooseArray< ADPoint > & adNormals() const
VariablePhiGradient _grad_phi_face
MooseArray< Point > _current_q_points_face_neighbor
The current quadrature points on the neighbor face.
const VectorVariablePhiGradient & gradPhiFace(const MooseVariableField< RealVectorValue > &) const
VectorVariablePhiCurl _vector_curl_phi_face
bool _need_dual
Whether dual shape functions need to be computed for mortar constraints.
auto index_range(const T &sizable)
const std::vector< Real > & jxWMortar() const
Returns a reference to JxW for mortar segment elements.
const FEVectorBase *const & getVectorFENeighbor(FEType type, unsigned int dim) const
GetVector a reference to a pointer that will contain the current 'neighbor' FE.
Key structure for APIs adding/caching local element residuals/Jacobians.
const dof_id_type & extraElemIDNeighbor(unsigned int id) const
Returns an integer ID of the current element given the index associated with the integer.
DenseVector< Number > _element_vector
A working vector to avoid repeated heap allocations when caching residuals that must have libMesh-lev...
SubdomainID _current_subdomain_id
The current subdomain ID.
const Elem *& sideElem()
Returns the side element.
VectorVariablePhiCurl & curlPhiFace(const MooseVariableField< RealVectorValue > &)
VariablePhiSecond & secondPhiFaceNeighbor(const MooseVariableField< RealEigenVector > &)
ElemSideBuilder _current_side_elem_builder
In place side element builder for _current_side_elem.
const FEBase *const & getFEFaceNeighbor(FEType type, unsigned int dim) const
Get a reference to a pointer that will contain the current "neighbor" FE.
std::map< unsigned int, const std::vector< Point > * > _holder_normals
Holds pointers to the dimension's normal vectors.
QBase * _current_qrule_face
quadrature rule used on faces
std::map< FEType, FEVectorBase * > _current_vector_fe_neighbor
The "neighbor" vector fe object that matches the current elem.
void clearCachedResiduals(GlobalDataKey)
Clears all of the residuals in _cached_residual_rows and _cached_residual_values. ...
const Node * _current_neighbor_node
The current neighboring node we are working with.
void cacheResidualsWithoutConstraints(const Residuals &residuals, const Indices &row_indices, Real scaling_factor, LocalDataKey, const std::set< TagID > &vector_tags)
Process the supplied residual values.
void clearCachedJacobian()
Clear any currently cached jacobians.
const BoundaryID & currentBoundaryID() const
Return the current boundary ID.
VectorVariablePhiDivergence _vector_div_phi_face_neighbor
const VariablePhiGradient & gradPhiFace() const
std::vector< std::vector< std::vector< DenseMatrix< Number > > > > _sub_Knl
dprimary/dlower (or dneighbor/dlower)
const OutputTools< OutputType >::VariablePhiValue & fePhiFace(FEType type) const
VariablePhiValue & phi(const MooseVariableField< RealEigenVector > &)
VariablePhiGradient & gradPhiNeighbor(const MooseVariableField< Real > &)
std::vector< VectorValue< DualReal > > _ad_dxyzdxi_map
AD quantities.
VariablePhiGradient & gradPhi(const MooseVariableField< RealEigenVector > &)
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)
VariablePhiValue & phiFace(const MooseVariableField< RealEigenVector > &)
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.
Key structure for APIs manipulating global vectors/matrices.