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" 26 #include <unordered_map> 83 template <
typename P,
typename C>
90 template <
typename P,
typename C>
111 template <
typename T>
114 const T *
const * ptr = &inref;
341 mooseAssert(
id <
_extra_elem_ids.size(),
"An invalid extra element integer id");
368 template <
bool is_ad>
527 bool allow_negative_qweights =
true);
638 unsigned int elem_side,
640 const std::vector<Point> *
const pts =
nullptr,
641 const std::vector<Real> *
const weights =
nullptr);
648 unsigned int neighbor_side,
650 const std::vector<Point> *
const pts,
651 const std::vector<Real> *
const weights =
nullptr);
656 void reinitDual(
const Elem *
elem,
const std::vector<Point> & pts,
const std::vector<Real> &
JxW);
662 const std::vector<Point> *
const pts =
nullptr,
663 const std::vector<Real> *
const weights =
nullptr);
700 void reinit(
const Elem *
elem,
const std::vector<Point> & reference_points);
715 void reinit(
const Elem *
elem,
unsigned int side,
const std::vector<Point> & reference_points);
733 unsigned int neighbor_side,
734 const std::vector<Point> * neighbor_reference_points =
nullptr);
740 unsigned int neighbor_side,
741 const std::vector<Point> & physical_points);
790 void prepareBlock(
unsigned int ivar,
unsigned jvar,
const std::vector<dof_id_type> & dof_indices);
793 const std::vector<dof_id_type> & idof_indices,
794 const std::vector<dof_id_type> & jdof_indices);
798 template <
typename T>
802 template <
typename T>
806 template <
typename T>
846 void addResidual(GlobalDataKey,
const std::vector<VectorTag> & vector_tags);
856 void addResidualLower(GlobalDataKey,
const std::vector<VectorTag> & vector_tags);
862 void addResidualScalar(GlobalDataKey,
const std::vector<VectorTag> & vector_tags);
868 void cacheResidual(GlobalDataKey,
const std::vector<VectorTag> & tags);
955 std::vector<dof_id_type> & dof_indices,
967 std::vector<dof_id_type> & dof_indices,
969 const std::set<TagID> & tags);
978 const std::vector<dof_id_type> & idof_indices,
979 const std::vector<dof_id_type> & jdof_indices,
990 const std::vector<dof_id_type> & idof_indices,
991 const std::vector<dof_id_type> & jdof_indices,
993 const std::set<TagID> & tags);
1030 std::vector<dof_id_type> & dof_indices,
1031 std::vector<dof_id_type> & neighbor_dof_indices,
1043 std::vector<dof_id_type> & dof_indices,
1044 std::vector<dof_id_type> & neighbor_dof_indices,
1046 const std::set<TagID> & tags);
1088 return _sub_Re[tag_id][var_num];
1097 return _sub_Rn[tag_id][var_num];
1106 return _sub_Rl[tag_id][var_num];
1155 const std::vector<dof_id_type> & dof_index,
1188 const std::set<TagID> & tags);
1197 const std::vector<dof_id_type> & idof_indices,
1198 const std::vector<dof_id_type> & jdof_indices,
1199 Real scaling_factor,
1212 template <
typename Res
iduals,
typename Indices>
1214 const Indices & row_indices,
1215 Real scaling_factor,
1217 const std::set<TagID> & vector_tags);
1226 template <
typename Res
iduals,
typename Indices>
1228 const Indices & row_indices,
1229 Real scaling_factor,
1231 const std::set<TagID> & matrix_tags);
1243 template <
typename Res
iduals,
typename Indices>
1245 const Indices & row_indices,
1246 Real scaling_factor,
1248 const std::set<TagID> & vector_tags);
1257 template <
typename Res
iduals,
typename Indices>
1259 const Indices & row_indices,
1260 Real scaling_factor,
1262 const std::set<TagID> & matrix_tags);
1264 std::vector<std::pair<MooseVariableFieldBase *, MooseVariableFieldBase *>> &
couplingEntries()
1268 const std::vector<std::pair<MooseVariableFieldBase *, MooseVariableFieldBase *>> &
1273 std::vector<std::pair<MooseVariableFieldBase *, MooseVariableFieldBase *>> &
1278 const std::vector<std::pair<MooseVariableFieldBase *, MooseVariableScalar *>> &
1283 const std::vector<std::pair<MooseVariableScalar *, MooseVariableFieldBase *>> &
1291 template <
typename T>
1588 template <
typename OutputType>
1595 template <
typename OutputType>
1602 template <
typename OutputType>
1608 template <
typename OutputType>
1616 template <
typename OutputType>
1619 template <
typename OutputType>
1622 template <
typename OutputType>
1625 template <
typename OutputType>
1629 template <
typename OutputType>
1636 template <
typename OutputType>
1643 template <
typename OutputType>
1649 template <
typename OutputType>
1657 template <
typename OutputType>
1664 template <
typename OutputType>
1671 template <
typename OutputType>
1679 template <
typename OutputType>
1686 template <
typename OutputType>
1694 template <
typename OutputType>
1703 template <
typename OutputType>
1711 template <
typename OutputType>
1719 template <
typename OutputType>
1727 template <
typename OutputType>
1735 template <
typename OutputType>
1742 template <
typename OutputType>
1749 template <
typename OutputType>
1757 template <
typename OutputType>
1777 std::vector<std::pair<unsigned int, unsigned short>> && disp_numbers_and_directions);
1792 for (
unsigned int j = 0; j < v.size(); ++j, i += ntest)
1815 for (
unsigned int k = 0; k < v.size(); ++k, i += ntest, j += pace)
1842 for (
unsigned int k = 0; k < v.rows(); ++k, i += ntest)
1843 ke(i, j) += v(k, k);
1847 const unsigned int saved_j = j;
1848 for (
unsigned int k = 0; k < v.rows(); ++k, i += ntest)
1851 for (
unsigned int l = 0; l < v.cols(); ++l, j += nphi)
1852 ke(i, j) += v(k, l);
1859 unsigned int rows = ke.
m();
1860 unsigned int cols = ke.
n();
1861 DenseVector<Real> diag(rows);
1862 for (
unsigned int i = 0; i < rows; i++)
1864 diag(i) = ke(i, i % cols);
1937 void havePRefinement(
const std::unordered_set<FEFamily> & disable_p_refinement_for_families);
1966 template <
typename Po
ints,
typename Coords>
1968 const Points & q_points,
1997 template <
typename OutputType>
2063 std::vector<dof_id_type> & dof_indices,
2064 const std::vector<Real> & scaling_factor,
2072 const std::vector<dof_id_type> & dof_indices,
2073 const std::vector<Real> & scaling_factor,
2080 std::vector<dof_id_type> & cached_residual_rows,
2082 const std::vector<dof_id_type> & dof_indices,
2083 const std::vector<Real> & scaling_factor,
2091 const std::vector<dof_id_type> & dof_indices,
2092 const std::vector<Real> & scaling_factor,
2102 const std::vector<dof_id_type> & idof_indices,
2103 const std::vector<dof_id_type> & jdof_indices);
2111 const std::vector<dof_id_type> & idof_indices,
2112 const std::vector<dof_id_type> & jdof_indices,
2121 const std::vector<dof_id_type> & idof_indices,
2122 const std::vector<dof_id_type> & jdof_indices,
2301 std::vector<std::pair<MooseVariableFieldBase *, MooseVariableFieldBase *>>
_cm_ff_entry;
2303 std::vector<std::pair<MooseVariableFieldBase *, MooseVariableScalar *>>
_cm_fs_entry;
2305 std::vector<std::pair<MooseVariableScalar *, MooseVariableFieldBase *>>
_cm_sf_entry;
2307 std::vector<std::pair<MooseVariableScalar *, MooseVariableScalar *>>
_cm_ss_entry;
2372 mutable std::map<unsigned int, std::map<FEType, FEBase *>>
_fe;
2374 mutable std::map<unsigned int, std::map<FEType, FEVectorBase *>>
_vector_fe;
2412 std::unique_ptr<libMesh::QBase>
vol;
2414 std::unique_ptr<libMesh::QBase>
face;
2429 std::unordered_map<SubdomainID, std::vector<QRules>>
_qrules;
2440 template <
typename T>
2450 auto neighbor_block =
neighbor->subdomain_id();
2451 if (neighbor_block ==
elem->subdomain_id())
2454 auto q_neighbor = rule_fn(
qrules(
dim, neighbor_block));
2455 if (q->get_order() > q_neighbor->get_order())
2470 "missing quadrature rules for specified block");
2472 "quadrature rules not sized property for dimension");
2476 "missing quadrature rules for specified block");
2477 mooseAssert(
_qrules[block].size() >
dim,
"quadrature rules not sized property for dimension");
2484 mutable std::map<unsigned int, std::map<FEType, FEBase *>>
_fe_face;
2526 mutable std::map<unsigned int, std::map<FEType, FEBase *>>
_fe_lower;
2630 std::vector<std::vector<DenseVector<Number>>>
_sub_Re;
2631 std::vector<std::vector<DenseVector<Number>>>
_sub_Rn;
2633 std::vector<std::vector<DenseVector<Number>>>
_sub_Rl;
2649 std::vector<std::vector<std::vector<DenseMatrix<Number>>>>
_sub_Kee;
2650 std::vector<std::vector<std::vector<DenseMatrix<Number>>>>
_sub_Keg;
2653 std::vector<std::vector<std::vector<DenseMatrix<Number>>>>
_sub_Ken;
2655 std::vector<std::vector<std::vector<DenseMatrix<Number>>>>
_sub_Kne;
2657 std::vector<std::vector<std::vector<DenseMatrix<Number>>>>
_sub_Knn;
2659 std::vector<std::vector<std::vector<DenseMatrix<Number>>>>
_sub_Kll;
2661 std::vector<std::vector<std::vector<DenseMatrix<Number>>>>
_sub_Kle;
2663 std::vector<std::vector<std::vector<DenseMatrix<Number>>>>
_sub_Kln;
2665 std::vector<std::vector<std::vector<DenseMatrix<Number>>>>
_sub_Kel;
2667 std::vector<std::vector<std::vector<DenseMatrix<Number>>>>
_sub_Knl;
2753 mutable std::map<FEType, ADTemplateVariablePhiGradient<RealVectorValue>>
2880 template <
typename OutputType>
2888 template <
typename OutputType>
2896 template <
typename OutputType>
2904 template <
typename OutputType>
2914 Assembly::feADGradPhi<RealVectorValue>(
FEType type)
const 2916 return _ad_vector_grad_phi_data[type];
2921 Assembly::feADGradPhiFace<RealVectorValue>(
FEType type)
const 2923 return _ad_vector_grad_phi_data_face[type];
2928 Assembly::fePhi<VectorValue<Real>>(
FEType type)
const;
2932 Assembly::feGradPhi<VectorValue<Real>>(
FEType type)
const;
2936 Assembly::feSecondPhi<VectorValue<Real>>(
FEType type)
const;
2940 Assembly::fePhiLower<VectorValue<Real>>(
FEType type)
const;
2944 Assembly::feDualPhiLower<VectorValue<Real>>(
FEType type)
const;
2948 Assembly::feGradPhiLower<VectorValue<Real>>(
FEType type)
const;
2952 Assembly::feGradDualPhiLower<VectorValue<Real>>(
FEType type)
const;
2956 Assembly::fePhiFace<VectorValue<Real>>(
FEType type)
const;
2960 Assembly::feGradPhiFace<VectorValue<Real>>(
FEType type)
const;
2964 Assembly::feSecondPhiFace<VectorValue<Real>>(
FEType type)
const;
2968 Assembly::fePhiNeighbor<VectorValue<Real>>(
FEType type)
const;
2972 Assembly::feGradPhiNeighbor<VectorValue<Real>>(
FEType type)
const;
2976 Assembly::feSecondPhiNeighbor<VectorValue<Real>>(
FEType type)
const;
2980 Assembly::fePhiFaceNeighbor<VectorValue<Real>>(
FEType type)
const;
2984 Assembly::feGradPhiFaceNeighbor<VectorValue<Real>>(
FEType type)
const;
2988 Assembly::feSecondPhiFaceNeighbor<VectorValue<Real>>(
FEType type)
const;
2992 Assembly::feCurlPhi<VectorValue<Real>>(
FEType type)
const;
2996 Assembly::feCurlPhiFace<VectorValue<Real>>(
FEType type)
const;
3000 Assembly::feCurlPhiNeighbor<VectorValue<Real>>(
FEType type)
const;
3004 Assembly::feCurlPhiFaceNeighbor<VectorValue<Real>>(
FEType type)
const;
3008 Assembly::feDivPhi<VectorValue<Real>>(
FEType type)
const;
3012 Assembly::feDivPhiFace<VectorValue<Real>>(
FEType type)
const;
3016 Assembly::feDivPhiNeighbor<VectorValue<Real>>(
FEType type)
const;
3020 Assembly::feDivPhiFaceNeighbor<VectorValue<Real>>(
FEType type)
const;
3026 return _ad_vector_grad_phi_data.at(v.feType());
3029 template <
typename Res
iduals,
typename Indices>
3032 const Indices & input_row_indices,
3033 const Real scaling_factor,
3035 const std::set<TagID> & vector_tags)
3037 mooseAssert(residuals.size() == input_row_indices.size(),
3038 "The number of residuals should match the number of dof indices");
3039 mooseAssert(residuals.size() >= 1,
"Why you calling me with no residuals?");
3044 if (residuals.size() == 1)
3049 residuals, input_row_indices, scaling_factor,
LocalDataKey{}, vector_tags);
3054 _row_indices.assign(input_row_indices.begin(), input_row_indices.end());
3069 template <
typename Res
iduals,
typename Indices>
3072 const Indices & row_indices,
3073 const Real scaling_factor,
3075 const std::set<TagID> & vector_tags)
3077 mooseAssert(residuals.size() == row_indices.size(),
3078 "The number of residuals should match the number of dof indices");
3079 mooseAssert(residuals.size() >= 1,
"Why you calling me with no residuals?");
3087 template <
typename Res
iduals,
typename Indices>
3090 const Indices & input_row_indices,
3091 const Real scaling_factor,
3093 const std::set<TagID> & matrix_tags)
3098 if (residuals.size() == 1)
3103 residuals, input_row_indices, scaling_factor,
LocalDataKey{}, matrix_tags);
3107 const auto & compare_dofs = residuals[0].derivatives().nude_indices();
3109 auto compare_dofs_set = std::set<dof_id_type>(compare_dofs.begin(), compare_dofs.end());
3111 for (
const auto i :
make_range(decltype(residuals.size())(1), residuals.size()))
3113 const auto & residual = residuals[i];
3114 auto current_dofs_set = std::set<dof_id_type>(residual.derivatives().nude_indices().begin(),
3115 residual.derivatives().nude_indices().end());
3116 mooseAssert(compare_dofs_set == current_dofs_set,
3117 "We're going to see whether the dof sets are the same. IIRC the degree of freedom " 3118 "dependence (as indicated by the dof index set held by the ADReal) has to be the " 3119 "same for every residual passed to this method otherwise constrain_element_matrix " 3131 _row_indices.assign(input_row_indices.begin(), input_row_indices.end());
3136 const auto & sparse_derivatives = residuals[i].derivatives();
3149 template <
typename Res
iduals,
typename Indices>
3152 const Indices & row_indices,
3153 const Real scaling_factor,
3155 const std::set<TagID> & matrix_tags)
3157 mooseAssert(residuals.size() == row_indices.size(),
3158 "The number of residuals should match the number of dof indices");
3159 mooseAssert(residuals.size() >= 1,
"Why you calling me with no residuals?");
3166 const auto row_index = row_indices[i];
3168 const auto & sparse_derivatives = residuals[i].derivatives();
3169 const auto & column_indices = sparse_derivatives.nude_indices();
3170 const auto & raw_derivatives = sparse_derivatives.nude_data();
3172 for (std::size_t j = 0; j < column_indices.size(); ++j)
3174 row_index, column_indices[j], raw_derivatives[j] * scaling_factor, {}, matrix_tags);
3194 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
MooseArray< VectorValue< ADReal > > _ad_normals
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.
void copyShapes(MooseVariableField< T > &v)
libMesh::ElemSideBuilder _compute_face_map_side_elem_builder
In place side element builder for computeFaceMap()
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
std::vector< ADReal > _ad_detadz_map
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.
unsigned int _max_cached_residuals
std::map< FEType, ADTemplateVariablePhiGradient< Real > > _ad_grad_phi_data_face
const OutputTools< OutputType >::VariablePhiCurl & feCurlPhi(FEType type) const
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...
VariablePhiSecond & secondPhiNeighbor(const MooseVariableField< RealEigenVector > &)
const VariablePhiGradient & gradPhiFaceNeighbor(const MooseVariableField< Real > &) const
const libMesh::FEType & feType() const
Get the type of finite element object.
std::vector< std::unique_ptr< FEBase > > _unique_fe_lower_helper
MooseArray< ADReal > _ad_coord
The AD version of the current coordinate transformation coefficients.
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.
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)
libMesh::QBase *const & writeableQRule()
Returns the reference to the current quadrature being used.
const bool & _computing_residual
Whether we are currently computing the residual.
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
void setFaceQRule(libMesh::QBase *qrule, unsigned int dim)
Set the qrule to be used for face integration.
libMesh::QBase *const & writeableQRuleNeighbor()
Returns the reference to the current quadrature being used on a current neighbor. ...
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 > &)
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.
const libMesh::QBase *const & qRuleFace() const
Returns the reference to the current quadrature being used on a current face.
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< 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
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.
libMesh::QBase * _current_qrule_neighbor
quadrature rule used on neighbors
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 > &)
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.
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.
std::vector< ADReal > _ad_detady_map
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
const MooseArray< Point > & qPointsFaceNeighbor() const
Returns the reference to the current quadrature points being used on the neighbor face...
std::vector< ADReal > _ad_dzetadz_map
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
void setVolumeQRule(libMesh::QBase *qrule, unsigned int dim)
Set the qrule to be used for volume integration.
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
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.
const MooseArray< Moose::GenericType< Point, is_ad > > & genericQPoints() const
const libMesh::QBase *const & qRuleMortar() const
Returns a reference to the quadrature rule for the mortar segments.
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...
libMesh::StaticCondensation * _sc
A pointer to the static condensation class. Null if not present.
VariablePhiValue & phi(const MooseVariableField< Real > &)
void setCoordinateTransformation(const libMesh::QBase *qrule, const Points &q_points, Coords &coord, SubdomainID sub_id)
std::map< unsigned int, std::map< FEType, FEVectorBase * > > _vector_fe_face_neighbor
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.
std::vector< std::unique_ptr< FEBase > > _unique_fe_helper
Containers for holding unique FE helper types if we are doing p-refinement.
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
libMesh::QBase * _current_qrule_face
quadrature rule used on faces
const VariablePhiValue & phiNeighbor(const MooseVariableField< Real > &) const
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::set< FEType > _need_second_derivative_neighbor
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
std::vector< VectorValue< ADReal > > _ad_dxyzdeta_map
VariablePhiSecond & secondPhiNeighbor(const MooseVariableField< Real > &)
DenseVector< Real > getJacobianDiagonal(DenseMatrix< Number > &ke)
Specialization of SubProblem for solving nonlinear equations plus auxiliary equations.
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.
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
std::unique_ptr< libMesh::QBase > face
area/face (meshdim-1) quadrature rule
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.
void addCachedResiduals(GlobalDataKey, const std::vector< VectorTag > &tags)
Pushes all cached residuals to the global residual vectors associated with each tag.
Data structure for tracking/grouping a set of quadrature rules for a particular dimensionality of mes...
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
Nonlinear system to be solved.
VectorVariablePhiValue _vector_phi_face
std::vector< VectorValue< ADReal > > _ad_dxyzdzeta_map
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.
void init(const libMesh::CouplingMatrix *cm)
Initialize the Assembly object and set the CouplingMatrix for use throughout.
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
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
std::unique_ptr< libMesh::QBase > vol
volume/elem (meshdim) quadrature rule
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.
std::vector< ADReal > _ad_dzetadx_map
void addJacobianLowerD(GlobalDataKey)
Add portions of the Jacobian of LowerLower, LowerSecondary, and SecondaryLower for boundary condition...
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
MooseArray< ADReal > _ad_curvatures
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...
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::vector< ADReal > _ad_dzetady_map
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
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.
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
std::vector< ADReal > _ad_dxidz_map
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 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 > &)
MooseMesh wraps a libMesh::Mesh object and enhances its capabilities by caching additional data and s...
libMesh::QBase * _current_qrule_lower
quadrature rule used on lower dimensional elements.
const VariablePhiGradient & gradPhi(const MooseVariableField< Real > &) const
std::vector< ADReal > _ad_detadx_map
void buildFaceFE(FEType type) const
Build FEs for a face with a type.
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 ...
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...
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.
std::vector< VectorValue< ADReal > > _ad_dxyzdxi_map
AD quantities.
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.
std::set< FEType > _need_neighbor_div
OutputTools< Real >::VariablePhiCurl VariablePhiCurl
std::vector< std::vector< std::vector< DenseMatrix< Number > > > > _sub_Kee
std::vector< VectorValue< ADReal > > _ad_d2xyzdxi2_map
std::vector< ADReal > _ad_jac
std::set< FEType > _need_curl
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...
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
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
libMesh::QBase * _current_qrule_volume
The current volumetric quadrature for the element.
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
libMesh::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...
const VariablePhiValue & phiFace() const
std::set< FEType > _need_second_derivative
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
std::set< FEType > _need_face_neighbor_div
FEGenericBase< Real > FEBase
libMesh::QBase * _qrule_msm
A qrule object for working on mortar segement elements.
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
VariablePhiValue _phi_face_neighbor
libMesh::ElemSideBuilder _current_neighbor_side_elem_builder
In place side element builder for _current_neighbor_side_elem.
OutputTools< Real >::VariablePhiDivergence VariablePhiDivergence
const Moose::CoordinateSystemType & coordSystem() const
Get the coordinate system type.
Real _current_lower_d_elem_volume
The current lower dimensional element volume.
const OutputTools< OutputType >::VariablePhiValue & fePhiNeighbor(FEType type) const
libMesh::QBase * _current_qrule
The current current quadrature rule being used (could be either volumetric or arbitrary - for dirac k...
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.
std::set< FEType > _need_div
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
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 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.
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.
bool hasStaticCondensation() const
OutputTools< Real >::VariablePhiGradient VariablePhiGradient
std::vector< ADReal > _ad_dxidx_map
std::vector< ADReal > _ad_dxidy_map
std::vector< VectorValue< ADReal > > _ad_d2xyzdxideta_map
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 SubdomainID ANY_BLOCK_ID
void havePRefinement(const std::unordered_set< FEFamily > &disable_p_refinement_for_families)
Indicate that we have p-refinement.
void setCurrentSubdomainID(SubdomainID i)
set the current subdomain ID
const std::vector< std::pair< MooseVariableScalar *, MooseVariableFieldBase * > > & scalarFieldCouplingEntries() const
const MooseArray< ADReal > & adJxWFace() const
MooseArray< VectorValue< ADReal > > _ad_q_points
const VariablePhiGradient & gradPhiNeighbor(const MooseVariableField< Real > &) const
VectorVariablePhiGradient _vector_grad_phi_face
MooseArray< VectorValue< ADReal > > _ad_q_points_face
VariablePhiValue & phiNeighbor(const MooseVariableField< RealEigenVector > &)
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
const libMesh::CouplingMatrix * _cm
Coupling matrices.
const VectorVariablePhiDivergence & divPhiFace(const MooseVariableField< RealVectorValue > &) const
const libMesh::QBase * attachQRuleElem(unsigned int dim, FEBase &fe)
Attaches the current elem/volume quadrature rule to the given fe.
void hasScalingVector()
signals this object that a vector containing variable scaling factors should be used when doing resid...
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. ...
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
std::unique_ptr< libMesh::QBase > fv_face
finite volume face/flux quadrature rule (meshdim-1)
std::map< FEType, std::unique_ptr< FEShapeData > > _fe_shape_data_dual_lower
void zeroCachedJacobian(GlobalDataKey)
Zero out previously-cached Jacobian rows.
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...
void constrain_element_vector(DenseVector< Number > &rhs, std::vector< dof_id_type > &dofs, bool asymmetric_constraint_rows=true) const
void setNeighborQRule(libMesh::QBase *qrule, unsigned int dim)
Set the qrule to be used for neighbor integration.
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 &)
void addStaticCondensation(libMesh::StaticCondensation &sc)
Set the static condensation object.
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
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()
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).
IntRange< T > make_range(T beg, T end)
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
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 libMesh::QBase *const & qRule() const
Returns the reference to the current quadrature being used.
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 libMesh::CouplingMatrix & _nonlocal_cm
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.
const libMesh::QBase *const & qRuleNeighbor() const
Returns the reference to the current quadrature being used on a current neighbor. ...
void clearCachedQRules()
Set the cached quadrature rules to nullptr.
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 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< 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
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.
const Real & elemVolume() const
Returns the reference to the current element volume.
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...
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.
void setLowerQRule(libMesh::QBase *qrule, unsigned int dim)
Set the qrule to be used for lower dimensional integration.
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 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 ...
const libMesh::DofMap & _dof_map
DOF map.
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
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...
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 libMesh::QBase * attachQRuleFace(unsigned int dim, FEBase &fe)
Attaches the current face/area quadrature rule to the given fe.
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...
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
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.
virtual void attach_quadrature_rule(QBase *q)=0
libMesh::ElemSideBuilder _current_side_elem_builder
In place side element builder for _current_side_elem.
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...
std::set< FEType > _need_face_div
const Real & sideElemVolume() const
Returns the reference to the volume of current side element.
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 > &)
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.
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.
std::vector< VectorValue< ADReal > > _ad_d2xyzdeta2_map
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
libMesh::QBase *const & writeableQRuleFace()
Returns the reference to the current quadrature being used on a current face.
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 > &)
VariablePhiGradient & gradPhi(const MooseVariableField< RealEigenVector > &)
void reinitFEFace(const Elem *elem, unsigned int side)
Just an internal helper function to reinit the face FE objects.
MooseArray< ADReal > _ad_JxW
MooseArray< ADReal > _ad_JxW_face
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.
void constrain_element_matrix(DenseMatrix< Number > &matrix, std::vector< dof_id_type > &elem_dofs, bool asymmetric_constraint_rows=true) const
Key structure for APIs manipulating global vectors/matrices.