26 #include "libmesh/equation_systems.h" 27 #include "libmesh/system.h" 28 #include "libmesh/dof_map.h" 29 #include "libmesh/string_to_enum.h" 43 "Whether or not to use libMesh's default amount of algebraic and geometric ghosting");
62 _factory(_app.getFactory()),
63 _default_ghosting(getParam<bool>(
"default_ghosting")),
64 _currently_computing_jacobian(false),
65 _currently_computing_residual_and_jacobian(false),
66 _computing_nonlinear_residual(false),
67 _currently_computing_residual(false),
68 _safe_access_tagged_matrices(false),
69 _safe_access_tagged_vectors(false),
70 _have_ad_objects(false),
71 _output_functors(false),
72 _typed_vector_tags(2),
73 _have_p_refinement(false)
96 mooseError(
"Vector tag type cannot be VECTOR_TAG_ANY");
103 mooseAssert(
_vector_tags[vector_tag._id] == vector_tag,
"Vector tags index mismatch");
104 if (vector_tag._name == tag_name_upper)
106 if (vector_tag._type !=
type)
107 mooseError(
"While attempting to add vector tag with name '",
111 ",\na tag with the same name but type ",
113 " was found.\n\nA tag can only exist with one type.");
115 return vector_tag._id;
123 _vector_tags.emplace_back(new_tag_id, new_tag_type_id, tag_name_upper,
type);
142 if (vector_tag._name == tag_name_upper)
166 mooseError(
"Vector tag with ID ", tag_id,
" does not exist");
171 std::vector<VectorTag>
176 std::vector<VectorTag> tags;
177 tags.reserve(tag_ids.size());
178 for (
const auto & tag_id : tag_ids)
183 const std::vector<VectorTag> &
210 return search->second;
212 std::string message =
213 tag_name_upper ==
"TIME" 214 ?
".\n\nThis may occur if " 215 "you have a TimeKernel in your problem but did not specify a transient executioner." 217 mooseError(
"Vector tag '", tag_name_upper,
"' does not exist", message);
225 mooseError(
"Vector tag with ID ", tag_id,
" does not exist");
235 mooseError(
"Vector tag with ID ", tag_id,
" does not exist");
247 if (vector_tag._id != tag_id)
248 mooseError(
"Vector tag ", vector_tag._id,
" id mismatch in _vector_tags");
250 mooseError(
"Vector tag '", vector_tag._name,
"' has type VECTOR_TAG_ANY");
254 mooseError(
"Vector tag ", vector_tag._id,
" is not in _vector_tags_name_map");
255 else if (search->second != tag_id)
256 mooseError(
"Vector tag ", vector_tag._id,
" has incorrect id in _vector_tags_name_map");
258 unsigned int found_in_type = 0;
263 if (vector_tag_type == vector_tag)
266 if (vector_tag_type._type_id != tag_type_id)
267 mooseError(
"Type ID for Vector tag ", tag_id,
" is incorrect");
271 if (found_in_type == 0)
272 mooseError(
"Vector tag ", tag_id,
" not found in _typed_vector_tags");
273 if (found_in_type > 1)
274 mooseError(
"Vector tag ", tag_id,
" found multiple times in _typed_vector_tags");
277 unsigned int num_typed_vector_tags = 0;
279 num_typed_vector_tags += typed_vector_tags.size();
281 mooseError(
"Size mismatch between _vector_tags and _typed_vector_tags");
283 mooseError(
"Size mismatch between _vector_tags and _vector_tags_name_map");
290 const std::vector<VectorTag> & input_vector_tags,
291 std::set<TagID> & selected_tags)
293 selected_tags.clear();
294 for (
const auto & vector_tag : input_vector_tags)
296 selected_tags.insert(vector_tag._id);
301 const std::map<TagName, TagID> & input_matrix_tags,
302 std::set<TagID> & selected_tags)
304 selected_tags.clear();
305 for (
const auto & matrix_tag_pair : input_matrix_tags)
306 if (system.
hasMatrix(matrix_tag_pair.second))
307 selected_tags.insert(matrix_tag_pair.second);
350 "If this is a TimeKernel then this may have happened because you didn't " 351 "specify a Transient Executioner.");
389 const std::set<TagID> &
395 const std::set<TagID> &
430 const std::set<TagID> &
436 const std::set<TagID> &
446 if (!moose_vars.empty())
453 const std::set<MooseVariableFEBase *> &
472 std::set<SubdomainID>
475 std::set<SubdomainID>
blocks;
479 const std::set<std::string> & prop_names = it.second;
480 std::set<std::string>::iterator name_it = prop_names.find(prop_name);
481 if (name_it != prop_names.end())
488 std::vector<SubdomainName>
492 std::vector<SubdomainName> block_names;
493 block_names.reserve(
blocks.size());
494 for (
const auto & block_id :
blocks)
500 std::ostringstream oss;
504 block_names.push_back(
name);
517 if (it->second.count(prop_name) > 0)
527 std::set<BoundaryID> boundaries;
531 const std::set<std::string> & prop_names = it.second;
532 std::set<std::string>::iterator name_it = prop_names.find(prop_name);
533 if (name_it != prop_names.end())
534 boundaries.insert(it.first);
540 std::vector<BoundaryName>
544 std::vector<BoundaryName> boundary_names;
545 boundary_names.reserve(boundaries.size());
548 for (
const auto & bnd_id : boundaries)
552 name =
"ANY_BOUNDARY_ID";
558 std::ostringstream oss;
563 boundary_names.push_back(
name);
566 return boundary_names;
576 if (it->second.count(prop_name) > 0)
609 const std::string & name)
617 const std::string & name)
626 std::set<SubdomainID> all_ids(
mesh().meshSubdomains());
628 std::stringstream errors;
636 std::set<SubdomainID> check_ids = {check_id};
639 for (
const auto &
id : check_ids)
642 for (
const auto & prop_it : check_it.second)
651 if (check_name.empty())
652 check_name = std::to_string(
id);
653 errors <<
"Material property '" << prop_it.second <<
"', requested by '" << prop_it.first
654 <<
"' is not defined on block " << check_name <<
"\n";
660 if (!errors.str().empty())
673 std::stringstream errors;
683 std::set<BoundaryID> check_ids{check_id};
684 if (check_id == any_id)
688 for (
const auto &
id : check_ids)
691 for (
const auto & prop_it : check_it.second)
702 if (check_name.empty())
703 check_name = std::to_string(
id);
704 errors <<
"Material property '" << prop_it.second <<
"', requested by '" << prop_it.first
705 <<
"' is not defined on boundary " << check_name <<
"\n";
711 if (!errors.str().empty())
719 "The nonlinear system number is higher than the number of systems we have!");
741 const std::map<MooseObjectName, std::set<std::string>> &
776 std::map<subdomain_id_type, std::string>::const_iterator pos = name_map.find(check_id);
777 if (pos != name_map.end())
816 template <
typename T>
819 const std::string & var_name,
822 const std::vector<T> & systems,
834 var = &(systems[sys_num]->getVariable(tid, var_name));
842 var = &(systems[sys_num]->getVariable(tid, var_name));
847 std::string expected_var_type_string =
850 expected_var_type_string,
854 "Did you specify an auxiliary variable when you meant to specify a nonlinear " 855 "variable (or vice-versa)?");
860 (expected_var_field_type == var->
fieldType()))
864 std::string expected_var_field_type_string =
869 expected_var_field_type_string,
873 "Did you specify a ",
874 var_field_type_string,
875 " variable when you meant to specify a ",
876 expected_var_field_type_string,
885 const std::vector<Point> *
const pts,
886 const std::vector<Real> *
const weights,
904 nl.reinitElemFace(elem, side, tid);
915 current_assembly.prepareJacobianBlock();
917 current_assembly.prepareResidual();
922 unsigned int neighbor_side,
924 const std::vector<Point> *
const pts,
925 const std::vector<Real> *
const weights,
941 nl.prepareNeighbor(tid);
944 nl.reinitNeighborFace(neighbor_elem, neighbor_side, tid);
959 const std::vector<Point> *
const pts,
960 const std::vector<Real> *
const weights)
971 nl.prepareLowerD(tid);
978 nl.reinitLowerD(tid);
1007 &algebraic_gf, std::vector<std::shared_ptr<GhostingFunctor>>(n_sys - 1));
1008 mooseAssert(pr.second,
"We are adding a duplicate algebraic ghosting functor");
1009 auto & clones_vec = pr.first->second;
1011 for (MooseIndex(n_sys) i = 1; i < n_sys; ++i)
1014 std::shared_ptr<GhostingFunctor> clone_alg_gf = algebraic_gf.
clone();
1018 clones_vec[i - 1] = clone_alg_gf;
1030 eq.
get_system(0).get_dof_map().add_algebraic_ghosting_functor(algebraic_gf, to_mesh);
1040 &coupling_gf, std::vector<std::shared_ptr<GhostingFunctor>>(num_nl_sys - 1));
1041 mooseAssert(pr.second,
"We are adding a duplicate coupling functor");
1042 auto & clones_vec = pr.first->second;
1044 for (
const auto i :
make_range(std::size_t(1), num_nl_sys))
1047 std::shared_ptr<GhostingFunctor> clone_coupling_gf = coupling_gf.
clone();
1051 clones_vec[i - 1] = clone_coupling_gf;
1073 const bool found_in_root_sys =
1079 const bool found_in_our_map =
1081 mooseAssert(found_in_root_sys == found_in_our_map,
1082 "If the ghosting functor exists in the root DofMap, then we need to have a key for " 1083 "it in our gf to clones map");
1086 if (found_in_root_sys)
1094 auto & clones_vec = it->second;
1095 mooseAssert((n_sys - 1) == clones_vec.size(),
1096 "The size of the gf clones vector doesn't match the number of systems minus one");
1097 if (clones_vec.empty())
1099 mooseAssert(n_sys == 1,
"The clones vector should only be empty if there is only one system");
1104 eq.
get_system(i + 1).get_dof_map().remove_algebraic_ghosting_functor(*clones_vec[i]);
1123 const bool found_in_our_map =
1125 mooseAssert(found_in_root_sys == found_in_our_map,
1126 "If the ghosting functor exists in the root DofMap, then we need to have a key for " 1127 "it in our gf to clones map");
1130 if (found_in_root_sys)
1138 auto & clones_vec = it->second;
1139 mooseAssert((num_nl_sys - 1) == clones_vec.size(),
1140 "The size of the gf clones vector doesn't match the number of systems minus one");
1141 if (clones_vec.empty())
1143 mooseAssert(num_nl_sys == 1,
1144 "The clones vector should only be empty if there is only one nonlinear system");
1149 eq.
get_system(i + 1).get_dof_map().remove_coupling_functor(*clones_vec[i]);
1188 for (
auto & pr : map)
1189 pr.second->timestepSetup();
1196 for (
auto & pr : map)
1197 pr.second->customSetup(exec_type);
1204 for (
auto & pr : map)
1205 pr.second->residualSetup();
1212 for (
auto & pr : map)
1213 pr.second->jacobianSetup();
1226 for (
const auto & [functor_wrapper_name, functor_wrapper] : functors)
1228 const auto & [true_functor_type, non_ad_functor, ad_functor] = functor_wrapper;
1229 mooseAssert(non_ad_functor->wrapsNull() == ad_functor->wrapsNull(),
"These must agree");
1230 const auto functor_name =
removeSubstring(functor_wrapper_name,
"wraps_");
1231 if (non_ad_functor->wrapsNull())
1233 "No functor ever provided with name '",
1235 "', which was requested by '",
1239 : ad_functor->ownsWrappedFunctor())
1240 mooseError(
"Functor envelopes should not own the functors they wrap, but '",
1242 "' is owned by the wrapper. Please open a MOOSE issue for help resolving this.");
1249 _console <<
"[DBG] Wrapped functors found in Subproblem" << std::endl;
1250 std::string functor_names =
"[DBG] ";
1251 for (
const auto & functor_pair :
_functors[0])
1252 functor_names += std::regex_replace(functor_pair.first, std::regex(
"wraps_"),
"") +
" ";
1253 if (functor_names.size())
1254 functor_names.pop_back();
1255 _console << functor_names << std::endl;
1263 _console <<
"[DBG] Requestors for wrapped functor " 1264 << std::regex_replace(functor, std::regex(
"wraps_"),
"") << std::endl;
1272 mooseAssert(tid <
_functors.size(),
"Too large a thread ID");
1274 return (functors.find(
"wraps_" +
name) != functors.end());
1334 std::unordered_set<FEFamily> disable_families;
1337 disable_families.insert(family);
1344 for (
const auto family : disable_families)
1345 for (
const auto i :
make_range(eq.n_systems()))
1347 auto & system = eq.get_system(i);
1348 auto & dof_map = system.get_dof_map();
1349 for (
const auto vg :
make_range(system.n_variable_groups()))
1351 const auto & var_group = system.variable_group(vg);
1352 if (var_group.type().family == family)
1353 dof_map.should_p_refine(vg,
false);
1369 auto family = Utility::string_to_enum<FEFamily>(params.
get<
MooseEnum>(
"family"));
1372 flag = params.
get<
bool>(
"disable_p_refinement");
1375 if (!inserted && flag != it->second)
1376 mooseError(
"'disable_p_refinement' not set consistently for variables in ", family);
1388 const std::string & var_name,
1391 const std::vector<std::shared_ptr<SolverSystem>> & nls,
1395 const std::string & var_name,
1398 const std::vector<std::unique_ptr<DisplacedSystem>> & nls,
virtual MooseMesh & mesh()=0
virtual void addCachedResidual(const THREAD_ID tid)
void cloneCouplingGhostingFunctor(libMesh::GhostingFunctor &coupling_gf, bool to_mesh=true)
Creates (n_sys - 1) clones of the provided coupling ghosting functor (corresponding to the nonlinear ...
unsigned int getAxisymmetricRadialCoord() const
Returns the desired radial direction for RZ coordinate transformation.
virtual TagID getVectorTagID(const TagName &tag_name) const
Get a TagID from a TagName.
void reinitNeighborLowerDElem(const Elem *elem, const THREAD_ID tid=0)
reinitialize a neighboring lower dimensional element
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 ...
std::map< TagName, TagID > _matrix_tag_name_to_tag_id
The currently declared tags.
virtual void clearActiveFEVariableCoupleableMatrixTags(const THREAD_ID tid)
virtual unsigned int nNonlinearIterations(const unsigned int nl_sys_num) const
virtual void clearActiveFEVariableCoupleableVectorTags(const THREAD_ID tid)
std::string join(Iterator begin, Iterator end, const std::string &delimiter)
Python-like join function for strings over an iterator range.
virtual bool hasBoundaryMaterialProperty(BoundaryID boundary_id, const std::string &prop_name)
Check if a material property is defined on a block.
virtual void setActiveScalarVariableCoupleableMatrixTags(std::set< TagID > &mtags, const THREAD_ID tid)
MooseVariableFieldBase & getVariableHelper(const THREAD_ID tid, const std::string &var_name, Moose::VarKindType expected_var_type, Moose::VarFieldType expected_var_field_type, const std::vector< T > &nls, const SystemBase &aux) const
Helper function called by getVariable that handles the logic for checking whether Variables of the re...
std::map< BoundaryID, std::multimap< std::string, std::string > > _map_boundary_material_props_check
The DiracKernelInfo object is a place where all the Dirac points added by different DiracKernels are ...
const std::set< TagID > & getActiveScalarVariableCoupleableVectorTags(const THREAD_ID tid) const
void removeCouplingGhostingFunctor(libMesh::GhostingFunctor &coupling_gf)
Remove a coupling ghosting functor from this problem's DofMaps.
unsigned int n_systems() const
std::string toLower(const std::string &name)
Convert supplied string to lower case.
virtual std::set< BoundaryID > getMaterialPropertyBoundaryIDs(const std::string &prop_name)
Get a vector containing the block ids the material property is defined on.
std::set< GhostingFunctor *>::const_iterator coupling_functors_begin() const
void setCurrentBoundaryID(BoundaryID i)
set the current boundary ID
virtual void reinitLowerDElem(const Elem *lower_d_elem, const THREAD_ID tid, const std::vector< Point > *const pts=nullptr, const std::vector< Real > *const weights=nullptr)
bool hasVector(const std::string &tag_name) const
Check if the named vector exists in the system.
void addAlgebraicGhostingFunctor(libMesh::GhostingFunctor &algebraic_gf, bool to_mesh=true)
Add an algebraic ghosting functor to this problem's DofMaps.
std::string toUpper(const std::string &name)
Convert supplied string to upper case.
virtual void storeSubdomainZeroMatProp(SubdomainID block_id, const MaterialPropertyName &name)
Adds to a map based on block ids of material properties for which a zero value can be returned...
virtual const std::vector< VectorTag > & currentResidualVectorTags() const =0
Return the residual vector tags we are currently computing.
virtual bool hasBlockMaterialProperty(SubdomainID block_id, const std::string &prop_name)
Check if a material property is defined on a block.
const std::set< TagID > & getActiveFEVariableCoupleableMatrixTags(const THREAD_ID tid) const
std::string restrictionBoundaryCheckName(BoundaryID check_id)
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.
static InputParameters validParams()
void cloneAlgebraicGhostingFunctor(libMesh::GhostingFunctor &algebraic_gf, bool to_mesh=true)
Creates (n_sys - 1) clones of the provided algebraic ghosting functor (corresponding to the nonlinear...
virtual const SystemBase & systemBaseNonlinear(const unsigned int sys_num) const =0
Return the nonlinear system object as a base class reference given the system number.
const std::set< TagID > & getActiveFEVariableCoupleableVectorTags(const THREAD_ID tid) const
std::unordered_set< TagID > _not_zeroed_tagged_vectors
the list of vector tags that will not be zeroed when all other tags are
virtual unsigned int currentNlSysNum() const =0
void addConsumedPropertyName(const MooseObjectName &obj_name, const std::string &prop_name)
Helper for tracking the object that is consuming a property for MaterialPropertyDebugOutput.
const MeshBase * get_mesh() const
std::map< std::string, std::set< std::string > > _functor_to_requestors
The requestors of functors where the key is the prop name and the value is a set of names of requesto...
virtual void setActiveElementalMooseVariables(const std::set< MooseVariableFieldBase *> &moose_vars, const THREAD_ID tid)
Set the MOOSE variables to be reinited on each element.
virtual void setCurrentBoundaryID(BoundaryID bid, const THREAD_ID tid)
sets the current boundary ID in assembly
virtual void storeSubdomainDelayedCheckMatProp(const std::string &requestor, SubdomainID block_id, const std::string &name)
Adds to a map based on block ids of material properties to validate.
virtual void setCurrentLowerDElem(const Elem *const lower_d_elem, const THREAD_ID tid)
Set the current lower dimensional element.
virtual void reinitLowerD(THREAD_ID tid)
Compute the values of the variables on the lower dimensional element.
virtual TagID addVectorTag(const TagName &tag_name, const Moose::VectorTagType type=Moose::VECTOR_TAG_RESIDUAL)
Create a Tag.
virtual const std::set< MooseVariableFieldBase * > & getActiveElementalMooseVariables(const THREAD_ID tid) const
Get the MOOSE variables to be reinited on each element.
virtual void addCachedJacobian(const THREAD_ID tid)
virtual void residualSetup()
virtual void storeBoundaryZeroMatProp(BoundaryID boundary_id, const MaterialPropertyName &name)
Adds to a map based on boundary ids of material properties for which a zero value can be returned...
Class that hold the whole problem being solved.
virtual libMesh::System & system()=0
Get the reference to the libMesh system.
bool vectorTagNotZeroed(const TagID tag) const
Checks if a vector tag is in the list of vectors that will not be zeroed when other tagged vectors ar...
std::unordered_map< libMesh::GhostingFunctor *, std::vector< std::shared_ptr< libMesh::GhostingFunctor > > > _root_coupling_gf_to_sys_clones
A map from a root coupling ghosting functor, e.g.
virtual void storeBoundaryDelayedCheckMatProp(const std::string &requestor, BoundaryID boundary_id, const std::string &name)
Adds to a map based on boundary ids of material properties to validate.
virtual bool hasMatrix(TagID tag) const
Check if the tagged matrix exists in the system.
void reinitFVFace(const THREAD_ID tid, const FaceInfo &fi)
reinitialize the finite volume assembly data for the provided face and thread
std::unique_ptr< T_DEST, T_DELETER > dynamic_pointer_cast(std::unique_ptr< T_SRC, T_DELETER > &src)
These are reworked from https://stackoverflow.com/a/11003103.
static void selectVectorTagsFromSystem(const SystemBase &system, const std::vector< VectorTag > &input_vector_tags, std::set< TagID > &selected_tags)
Select the vector tags which belong to a specific system.
bool _output_functors
Whether to output a list of the functors used and requested (currently only at initialSetup) ...
This class provides an interface for common operations on field variables of both FE and FV types wit...
virtual void jacobianSetup()
The following methods are specializations for using the libMesh::Parallel::packed_range_* routines fo...
void setActiveVariableCoupleableVectorTags(const std::set< TagID > &vtags, THREAD_ID tid)
Set the active vector tags for the variables.
void showFunctors() const
Lists all functors in the problem.
Base class for a system (of equations)
const BoundaryInfo & get_boundary_info() const
const bool & currentlyComputingResidualAndJacobian() const
Returns true if the problem is in the process of computing the residual and the Jacobian.
const T_sys & get_system(std::string_view name) const
std::vector< VectorTag > _vector_tags
The declared vector tags.
virtual void clearActiveElementalMooseVariables(const THREAD_ID tid)
Clear the active elemental MooseVariableFieldBase.
virtual const std::string & name() const
Get the name of the class.
void add_coupling_functor(GhostingFunctor &coupling_functor, bool to_mesh=true)
virtual void markMatPropRequested(const std::string &)
Helper method for adding a material property name to the _material_property_requested set...
void clearAllDofIndices()
Clear dof indices from variables in nl and aux systems.
std::vector< std::set< TagID > > _active_sc_var_coupleable_vector_tags
std::map< BoundaryID, std::set< MaterialPropertyName > > _zero_boundary_material_props
virtual 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, const THREAD_ID tid=0)
reinitialize FE objects on a given neighbor element on a given side at a given set of reference point...
void cacheJacobian(GlobalDataKey)
Takes the values that are currently in _sub_Kee and appends them to the cached values.
bool verifyVectorTags() const
Verify the integrity of _vector_tags and _typed_vector_tags.
void addCachedResiduals(GlobalDataKey, const std::vector< VectorTag > &tags)
Pushes all cached residuals to the global residual vectors associated with each tag.
void preparePRefinement()
Prepare DofMap and Assembly classes with our p-refinement information.
const std::set< TagID > & getActiveScalarVariableCoupleableMatrixTags(const THREAD_ID tid) const
std::map< BoundaryID, std::set< std::string > > _map_boundary_material_props
Map for boundary material properties (boundary_id -> list of properties)
virtual Real finalNonlinearResidual(const unsigned int nl_sys_num) const
void setActiveScalarVariableCoupleableVectorTags(const std::set< TagID > &vtags, THREAD_ID tid)
Set the active vector tags for the scalar variables.
virtual void customSetup(const ExecFlagType &exec_type)
virtual void checkBoundaryMatProps()
Checks boundary material properties integrity.
virtual void setActiveScalarVariableCoupleableVectorTags(std::set< TagID > &vtags, const THREAD_ID tid)
void prepareLowerD()
Prepare the Jacobians and residuals for a lower dimensional element.
bool automaticScaling() const
Automatic scaling getter.
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...
This data structure is used to store geometric and variable related metadata about each cell face in ...
virtual libMesh::EquationSystems & es()=0
std::unordered_map< FEFamily, bool > _family_for_p_refinement
Indicate whether a family is disabled for p-refinement.
virtual bool isMatPropRequested(const std::string &prop_name) const
Find out if a material property has been requested by any object.
std::map< MooseObjectName, std::set< std::string > > _consumed_material_properties
bool automaticScaling() const
Getter for whether we are performing automatic scaling.
static const std::unordered_set< FEFamily > _default_families_without_p_refinement
The set of variable families by default disable p-refinement.
MeshBase & getMesh()
Accessor for the underlying libMesh Mesh object.
void removeAlgebraicGhostingFunctor(libMesh::GhostingFunctor &algebraic_gf)
Remove an algebraic ghosting functor from this problem's DofMaps.
std::map< TagID, TagName > _matrix_tag_id_to_tag_name
Reverse map.
virtual bool hasNonlocalCoupling() const =0
Whether the simulation has active nonlocal coupling which should be accounted for in the Jacobian...
virtual DiracKernelInfo & diracKernelInfo()
virtual void setActiveFEVariableCoupleableVectorTags(std::set< TagID > &vtags, const THREAD_ID tid)
virtual TagID getMatrixTagID(const TagName &tag_name) const
Get a TagID from a TagName.
virtual const SystemBase & systemBaseAuxiliary() const =0
Return the auxiliary system object as a base class reference.
virtual void clearActiveScalarVariableCoupleableVectorTags(const THREAD_ID tid)
void cacheJacobianNeighbor(GlobalDataKey)
Takes the values that are currently in the neighbor Dense Matrices and appends them to the cached val...
unsigned int getAxisymmetricRadialCoord() const
Returns the desired radial direction for RZ coordinate transformation.
std::vector< std::multimap< std::string, std::pair< bool, bool > > > _functor_to_request_info
A multimap (for each thread) from unfilled functor requests to whether the requests were for AD funct...
boundary_id_type BoundaryID
virtual unsigned int nLinearIterations(const unsigned int nl_sys_num) const
void hasScalingVector(const unsigned int nl_sys_num)
Tells this problem that the assembly associated with the given nonlinear system number involves a sca...
VarKindType
Framework-wide stuff.
virtual std::size_t numSolverSystems() const =0
virtual void storeBoundaryMatPropName(BoundaryID boundary_id, const std::string &name)
Adds the given material property to a storage map based on boundary ids.
SubProblem(const InputParameters ¶meters)
std::unordered_map< libMesh::GhostingFunctor *, std::vector< std::shared_ptr< libMesh::GhostingFunctor > > > _root_alg_gf_to_sys_clones
A map from a root algebraic ghosting functor, e.g.
virtual void prepareNeighbor(THREAD_ID tid)
Prepare the system for use.
virtual TagID addMatrixTag(TagName tag_name)
Create a Tag.
std::string restrictionSubdomainCheckName(SubdomainID check_id)
Helper functions for checking MaterialProperties.
virtual Moose::VectorTagType vectorTagType(const TagID tag_id) const
virtual void reinitElemFaceRef(const Elem *elem, unsigned int side, Real tolerance, const std::vector< Point > *const pts, const std::vector< Real > *const weights=nullptr, const THREAD_ID tid=0)
reinitialize FE objects on a given element on a given side at a given set of reference points and the...
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 markFamilyPRefinement(const InputParameters ¶ms)
Mark a variable family for either disabling or enabling p-refinement with valid parameters of a varia...
const std::string & type() const
Get the type of this class.
virtual void checkBlockMatProps()
Checks block material properties integrity.
This is a "smart" enum class intended to replace many of the shortcomings in the C++ enum type It sho...
virtual void reinitNeighborFace(const Elem *elem, unsigned int side, THREAD_ID tid)
Compute the values of the variables at all the current points.
std::vector< VectorTag > getVectorTags(const std::set< TagID > &tag_ids) const
std::vector< BoundaryID > getBoundaryIDs(const libMesh::MeshBase &mesh, const std::vector< BoundaryName > &boundary_name, bool generate_unknown, const std::set< BoundaryID > &mesh_boundary_ids)
Gets the boundary IDs with their names.
virtual std::vector< SubdomainName > getMaterialPropertyBlockNames(const std::string &prop_name)
Get a vector of block id equivalences that the material property is defined on.
std::string & subdomain_name(subdomain_id_type id)
virtual bool vectorTagExists(const TagID tag_id) const
Check to see if a particular Tag exists.
std::string stringify(const T &t)
conversion to string
Moose::CoordinateSystemType getCoordSystem(SubdomainID sid) const
Get the coordinate system type, e.g.
virtual bool hasVariable(const std::string &var_name) const =0
Whether or not this problem has the variable.
virtual void clearActiveScalarVariableCoupleableMatrixTags(const THREAD_ID tid)
void showFunctorRequestors() const
Lists all functors and all the objects that requested them.
virtual bool hasVariable(const std::string &var_name) const
Query a system for a variable.
bool doingPRefinement() const
void reinitMortarElem(const Elem *elem)
reinitialize a mortar segment mesh element in order to get a proper JxW
std::string & sideset_name(boundary_id_type id)
virtual void cacheJacobianNeighbor(const THREAD_ID tid)
std::vector< std::map< std::string, std::unique_ptr< Moose::FunctorAbstract > > > _pbblf_functors
Container to hold PiecewiseByBlockLambdaFunctors.
std::vector< std::set< TagID > > _active_fe_var_coupleable_vector_tags
void reinitFVFace(const FaceInfo &fi)
std::set< GhostingFunctor *>::const_iterator algebraic_ghosting_functors_end() const
virtual void cacheResidual(const THREAD_ID tid)
virtual void timestepSetup()
void removeSubstring(std::string &main, const std::string &sub)
find, erase, length algorithm for removing a substring from a string
std::vector< std::set< MooseVariableFieldBase * > > _active_elemental_moose_variables
This is the set of MooseVariableFieldBase that will actually get reinited by a call to reinit(elem) ...
virtual bool nlConverged(const unsigned int nl_sys_num)
void havePRefinement(const std::unordered_set< FEFamily > &disable_p_refinement_for_families)
Indicate that we have p-refinement.
virtual std::set< SubdomainID > getMaterialPropertyBlocks(const std::string &prop_name)
Get a vector containing the block ids the material property is defined on.
void addCouplingGhostingFunctor(libMesh::GhostingFunctor &coupling_gf, bool to_mesh=true)
Add a coupling functor to this problem's DofMaps.
virtual void initialSetup()
void remove_coupling_functor(GhostingFunctor &coupling_functor)
bool _have_p_refinement
Whether p-refinement has been requested at any point during the simulation.
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
RelationshipManagers are used for describing what kinds of non-local resources are needed for an obje...
void hasScalingVector()
signals this object that a vector containing variable scaling factors should be used when doing resid...
std::map< SubdomainID, std::set< MaterialPropertyName > > _zero_block_material_props
Set of properties returned as zero properties.
Class for containing MooseEnum item information.
virtual std::vector< BoundaryName > getMaterialPropertyBoundaryNames(const std::string &prop_name)
Get a vector of block id equivalences that the material property is defined on.
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...
std::map< TagName, TagID > _vector_tags_name_map
Map of vector tag TagName to TagID.
std::vector< unsigned int > _has_active_elemental_moose_variables
Whether or not there is currently a list of active elemental moose variables.
std::vector< std::vector< VectorTag > > _typed_vector_tags
The vector tags associated with each VectorTagType This is kept separate from _vector_tags for quick ...
virtual Assembly & assembly(const THREAD_ID tid, const unsigned int sys_num)=0
virtual const SystemBase & systemBaseSolver(const unsigned int sys_num) const =0
Return the solver system object as a base class reference given the system number.
const std::string & get_sideset_name(boundary_id_type id) const
static void selectMatrixTagsFromSystem(const SystemBase &system, const std::map< TagName, TagID > &input_matrix_tags, std::set< TagID > &selected_tags)
Select the matrix tags which belong to a specific system.
virtual std::pair< bool, unsigned int > determineSolverSystem(const std::string &var_name, bool error_if_not_found=false) const =0
void cacheJacobianNonlocal(GlobalDataKey)
Takes the values that are currently in _sub_Keg and appends them to the cached values.
IntRange< T > make_range(T beg, T end)
std::set< std::string > _material_property_requested
set containing all material property names that have been requested by getMaterialProperty* ...
virtual Moose::VarFieldType fieldType() const =0
Field type of this variable.
void mooseError(Args &&... args) const
Emits an error prefixed with object name and type.
virtual unsigned int numVectorTags(const Moose::VectorTagType type=Moose::VECTOR_TAG_ANY) const
The total number of tags, which can be limited to the tag type.
virtual void prepare(THREAD_ID tid)
Prepare the system for use.
virtual void setActiveFEVariableCoupleableMatrixTags(std::set< TagID > &mtags, const THREAD_ID tid)
virtual std::unique_ptr< GhostingFunctor > clone() const
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...
std::vector< std::multimap< std::string, std::tuple< TrueFunctorIs, std::unique_ptr< Moose::FunctorEnvelopeBase >, std::unique_ptr< Moose::FunctorEnvelopeBase > > > > _functors
A container holding pointers to all the functors in our problem.
Moose::CoordinateSystemType getCoordSystem(SubdomainID sid) const
virtual void cacheResidualNeighbor(const THREAD_ID tid)
virtual bool hasLinearVariable(const std::string &var_name) const
Whether or not this problem has this linear variable.
std::set< GhostingFunctor *>::const_iterator coupling_functors_end() const
virtual void reinitElemFace(const Elem *elem, unsigned int side, THREAD_ID tid)
Reinit assembly info for a side of an element.
virtual TagName vectorTagName(const TagID tag) const
Retrieve the name associated with a TagID.
const ConsoleStream _console
An instance of helper class to write streams to the Console objects.
virtual bool hasActiveElementalMooseVariables(const THREAD_ID tid) const
Whether or not a list of active elemental moose variables has been set.
virtual void prepareLowerD(THREAD_ID tid)
Prepare the system for use for lower dimensional elements.
static InputParameters validParams()
std::map< SubdomainID, std::multimap< std::string, std::string > > _map_block_material_props_check
Data structures of the requested material properties.
MooseVariableFieldBase & getVariable(THREAD_ID tid, const std::string &var_name) const
Gets a reference to a variable of with specified name.
void doingPRefinement(bool doing_p_refinement)
Indicate whether the kind of adaptivity we're doing is p-refinement.
const bool & currentlyComputingJacobian() const
Returns true if the problem is in the process of computing the Jacobian.
virtual std::size_t numNonlinearSystems() const =0
bool hasFunctor(const std::string &name, const THREAD_ID tid) const
checks whether we have a functor corresponding to name on the thread id tid
void remove_algebraic_ghosting_functor(GhostingFunctor &evaluable_functor)
std::set< GhostingFunctor *>::const_iterator algebraic_ghosting_functors_begin() const
const std::map< MooseObjectName, std::set< std::string > > & getConsumedPropertyMap() const
Return the map that tracks the object with consumed material properties.
Storage for all of the information pretaining to a vector tag.
DiracKernelInfo _dirac_kernel_info
virtual bool solverSystemConverged(const unsigned int sys_num)
std::map< SubdomainID, std::set< std::string > > _map_block_material_props
Map of material properties (block_id -> list of properties)
void add_algebraic_ghosting_functor(GhostingFunctor &evaluable_functor, bool to_mesh=true)
A class for storing the names of MooseObject by tag and object name.
const DofMap &dof_map LIBMESH_COMMA unsigned int std::string & set_subdomain_name_map()
void addCachedJacobian(GlobalDataKey)
Adds the values that have been cached by calling cacheJacobian() and or cacheJacobianNeighbor() to th...
const DofMap & get_dof_map() const
virtual const SystemBase & systemBaseLinear(const unsigned int sys_num) const =0
Return the linear system object as a base class reference given the system number.
std::vector< std::set< TagID > > _active_fe_var_coupleable_matrix_tags
virtual const VectorTag & getVectorTag(const TagID tag_id) const
Get a VectorTag from a TagID.
std::vector< std::set< TagID > > _active_sc_var_coupleable_matrix_tags
void clearAllDofIndices()
Clear all dof indices from moose variables.
virtual void storeSubdomainMatPropName(SubdomainID block_id, const std::string &name)
Adds the given material property to a storage map based on block ids.
virtual void cacheJacobian(const THREAD_ID tid)
void reinitMortarElem(const Elem *elem, const THREAD_ID tid=0)
Reinit a mortar element to obtain a valid JxW.
virtual std::size_t numLinearSystems() const =0
virtual bool hasAuxiliaryVariable(const std::string &var_name) const
Whether or not this problem has this auxiliary variable.
virtual bool matrixTagExists(const TagName &tag_name) const
Check to see if a particular Tag exists.
virtual TagName matrixTagName(TagID tag)
Retrieve the name associated with a TagID.
void addNotZeroedVectorTag(const TagID tag)
Adds a vector tag to the list of vectors that will not be zeroed when other tagged vectors are...
const BoundaryID ANY_BOUNDARY_ID
Key structure for APIs manipulating global vectors/matrices.