27 #include "libmesh/quadrature_gauss.h" 28 #include "libmesh/node_range.h" 29 #include "libmesh/numeric_vector.h" 30 #include "libmesh/default_coupling.h" 31 #include "libmesh/string_to_enum.h" 38 _sys(subproblem.es().add_system<System>(
name)),
39 _current_solution(_sys.current_local_solution.
get()),
40 _aux_scalar_storage(_app.getExecuteOnEnum()),
41 _nodal_aux_storage(_app.getExecuteOnEnum()),
42 _mortar_nodal_aux_storage(_app.getExecuteOnEnum()),
43 _elemental_aux_storage(_app.getExecuteOnEnum()),
44 _nodal_vec_aux_storage(_app.getExecuteOnEnum()),
45 _elemental_vec_aux_storage(_app.getExecuteOnEnum()),
46 _nodal_array_aux_storage(_app.getExecuteOnEnum()),
47 _elemental_array_aux_storage(_app.getExecuteOnEnum())
54 auto & dof_map =
_sys.get_dof_map();
55 dof_map.remove_algebraic_ghosting_functor(dof_map.default_algebraic_ghosting());
56 dof_map.set_implicit_neighbor_dofs(
false);
65 TIME_SECTION(
"initialSetup", 3,
"Initializing Auxiliary System");
202 const std::string & name,
207 auto fe_type = FEType(Utility::string_to_enum<Order>(parameters.
get<
MooseEnum>(
"order")),
208 Utility::string_to_enum<FEFamily>(parameters.
get<
MooseEnum>(
"family")));
210 if (var_type ==
"MooseVariableScalar")
236 if (var->feType().family ==
LAGRANGE)
246 if (avar->feType().family ==
LAGRANGE)
257 const std::string & name,
267 const std::string & name,
272 if (parameters.
get<std::string>(
"_moose_base") ==
"AuxKernel" ||
273 parameters.
get<std::string>(
"_moose_base") ==
"Bounds")
275 std::shared_ptr<AuxKernel> kernel =
277 if (kernel->isNodal())
279 if (kernel->isMortar())
288 else if (parameters.
get<std::string>(
"_moose_base") ==
"VectorAuxKernel")
290 std::shared_ptr<VectorAuxKernel> kernel =
292 if (kernel->isNodal())
294 if (kernel->isMortar())
295 mooseError(
"Vector mortar aux kernels not yet implemented");
302 else if (parameters.
get<std::string>(
"_moose_base") ==
"ArrayAuxKernel")
304 std::shared_ptr<ArrayAuxKernel> kernel =
306 if (kernel->isNodal())
308 if (kernel->isMortar())
309 mooseError(
"Vector mortar aux kernels not yet implemented");
317 "Attempting to add AuxKernel of type '" + kernel_name +
"' and name '" +
name +
318 "' to the auxiliary system with invalid _moose_base: " +
319 parameters.
get<std::string>(
"_moose_base"));
325 const std::string & name,
330 std::shared_ptr<AuxScalarKernel> kernel =
340 var->computeElemValues();
345 var->computeElemValues();
356 var->computeElemValuesFace();
361 var->reinitAuxNeighbor();
362 var->computeElemValuesFace();
397 if (
_vars[0].scalars().size() > 0)
405 if (
_vars[0].fieldVariables().size() > 0)
424 std::set<std::string>
427 std::set<std::string> depend_objects;
431 const std::vector<std::shared_ptr<AuxKernel>> & auxs =
433 for (
const auto & aux : auxs)
435 const std::set<UserObjectName> & uo = aux->getDependObjects();
436 depend_objects.insert(uo.begin(), uo.end());
442 const std::vector<std::shared_ptr<VectorAuxKernel>> & auxs =
444 for (
const auto & aux : auxs)
446 const std::set<UserObjectName> & uo = aux->getDependObjects();
447 depend_objects.insert(uo.begin(), uo.end());
453 const std::vector<std::shared_ptr<ArrayAuxKernel>> & auxs =
455 for (
const auto & aux : auxs)
457 const std::set<UserObjectName> & uo = aux->getDependObjects();
458 depend_objects.insert(uo.begin(), uo.end());
464 const std::vector<std::shared_ptr<AuxKernel>> & auxs =
466 for (
const auto & aux : auxs)
468 const std::set<UserObjectName> & uo = aux->getDependObjects();
469 depend_objects.insert(uo.begin(), uo.end());
475 const std::vector<std::shared_ptr<AuxKernel>> & auxs =
477 for (
const auto & aux : auxs)
479 const std::set<UserObjectName> & uo = aux->getDependObjects();
480 depend_objects.insert(uo.begin(), uo.end());
486 const std::vector<std::shared_ptr<VectorAuxKernel>> & auxs =
488 for (
const auto & aux : auxs)
490 const std::set<UserObjectName> & uo = aux->getDependObjects();
491 depend_objects.insert(uo.begin(), uo.end());
497 const std::vector<std::shared_ptr<ArrayAuxKernel>> & auxs =
499 for (
const auto & aux : auxs)
501 const std::set<UserObjectName> & uo = aux->getDependObjects();
502 depend_objects.insert(uo.begin(), uo.end());
506 return depend_objects;
509 std::set<std::string>
512 std::set<std::string> depend_objects;
516 const std::vector<std::shared_ptr<AuxKernel>> & auxs =
518 for (
const auto & aux : auxs)
520 const std::set<UserObjectName> & uo = aux->getDependObjects();
521 depend_objects.insert(uo.begin(), uo.end());
527 const std::vector<std::shared_ptr<VectorAuxKernel>> & auxs =
529 for (
const auto & aux : auxs)
531 const std::set<UserObjectName> & uo = aux->getDependObjects();
532 depend_objects.insert(uo.begin(), uo.end());
538 const std::vector<std::shared_ptr<ArrayAuxKernel>> & auxs =
540 for (
const auto & aux : auxs)
542 const std::set<UserObjectName> & uo = aux->getDependObjects();
543 depend_objects.insert(uo.begin(), uo.end());
549 const std::vector<std::shared_ptr<AuxKernel>> & auxs =
_nodal_aux_storage.getActiveObjects();
550 for (
const auto & aux : auxs)
552 const std::set<UserObjectName> & uo = aux->getDependObjects();
553 depend_objects.insert(uo.begin(), uo.end());
559 const std::vector<std::shared_ptr<AuxKernel>> & auxs =
561 for (
const auto & aux : auxs)
563 const std::set<UserObjectName> & uo = aux->getDependObjects();
564 depend_objects.insert(uo.begin(), uo.end());
570 const std::vector<std::shared_ptr<VectorAuxKernel>> & auxs =
572 for (
const auto & aux : auxs)
574 const std::set<UserObjectName> & uo = aux->getDependObjects();
575 depend_objects.insert(uo.begin(), uo.end());
581 const std::vector<std::shared_ptr<ArrayAuxKernel>> & auxs =
583 for (
const auto & aux : auxs)
585 const std::set<UserObjectName> & uo = aux->getDependObjects();
586 depend_objects.insert(uo.begin(), uo.end());
590 return depend_objects;
597 const std::vector<std::shared_ptr<AuxScalarKernel>> & objects = storage.
getActiveObjects(0);
599 std::set<TagID> needed_sc_var_matrix_tags;
600 std::set<TagID> needed_sc_var_vector_tags;
601 for (
const auto & obj : objects)
603 auto & sc_var_coup_vtags = obj->getScalarVariableCoupleableVectorTags();
604 needed_sc_var_vector_tags.insert(sc_var_coup_vtags.begin(), sc_var_coup_vtags.end());
606 auto & sc_var_coup_mtags = obj->getScalarVariableCoupleableMatrixTags();
607 needed_sc_var_matrix_tags.insert(sc_var_coup_mtags.begin(), sc_var_coup_mtags.end());
631 TIME_SECTION(
"computeScalarVars", 1);
641 const std::vector<std::shared_ptr<AuxScalarKernel>> & objects =
645 for (
const auto & obj : objects)
649 for (
const auto & var : scalar_vars)
665 TIME_SECTION(
"computeNodalVars", 3);
668 computeNodalVarsHelper<AuxKernel>(nodal);
674 TIME_SECTION(
"computeNodalVecVars", 3);
677 computeNodalVarsHelper<VectorAuxKernel>(nodal);
684 computeNodalVarsHelper<ArrayAuxKernel>(nodal);
690 TIME_SECTION(
"computeMortarNodalVars", 3);
695 "We don't allow creation of block restricted mortar nodal aux kernels.");
700 for (
const auto & [bnd_id, mortar_nodal_auxes] :
702 for (
const auto index :
index_range(mortar_nodal_auxes))
709 _fe_problem, mortar_nodal_warehouse, bnd_id, index);
710 Threads::parallel_reduce(bnd_nodes, mnabt);
715 "nodal Auxiliary variable computation:\n" +
716 std::string(e.what()));
721 "Auxiliary variable computation:\n" +
722 std::string(e.
what()));
724 catch (MetaPhysicL::LogicError & e)
742 TIME_SECTION(
"computeElementalVars", 3);
745 computeElementalVarsHelper<AuxKernel>(elemental);
751 TIME_SECTION(
"computeElementalVecVars", 3);
754 computeElementalVarsHelper<VectorAuxKernel>(elemental);
761 computeElementalVarsHelper<ArrayAuxKernel>(elemental);
766 std::vector<dof_id_type> & ,
767 std::vector<dof_id_type> &
776 std::vector<MooseVariableFEBase *> vars =
_vars[0].fieldVariables();
777 for (
const auto & var : vars)
781 FEType fe_type = var->feType();
782 if (fe_type.default_quadrature_order() > order)
783 order = fe_type.default_quadrature_order();
804 template <
typename AuxKernelType>
817 Threads::parallel_reduce(range, eavt);
822 "Auxiliary variable computation:\n" +
823 std::string(e.
what()));
837 TIME_SECTION(
"computeElementalVecVars", 3);
845 Threads::parallel_reduce(bnd_elems, eabt);
850 "elemental Auxiliary variable computation:\n" +
851 std::string(e.
what()));
863 template <
typename AuxKernelType>
874 Threads::parallel_reduce(range, navt);
884 TIME_SECTION(
"computeBoundaryObjects", 3);
891 Threads::parallel_reduce(bnd_nodes, nabt);
902 std::vector<Number> & rel_diff_norms)
const 906 const auto & dof_map =
_sys.get_dof_map();
911 std::vector<dof_id_type> local_indices_n;
912 dof_map.local_variable_indices(local_indices_n,
_mesh, n);
916 for (
const auto local_index : local_indices_n)
920 diff_norm_n += Utility::pow<2, Number>(
value - value_old);
921 norm_n += Utility::pow<2, Number>(
value);
926 diff_norm_n =
sqrt(diff_norm_n);
927 norm_n =
sqrt(norm_n);
928 rel_diff_norms[n] = diff_norm_n / norm_n;
934 template void AuxiliarySystem::computeElementalVarsHelper<VectorAuxKernel>(
938 template void AuxiliarySystem::computeNodalVarsHelper<VectorAuxKernel>(
std::string name(const ElemQuality q)
void addObject(std::shared_ptr< T > object, THREAD_ID tid=0, bool recurse=true) override
Adds an object to the storage structure.
ExecuteMooseObjectWarehouse< AuxKernel > _nodal_aux_storage
ExecuteMooseObjectWarehouse< AuxKernel > _mortar_nodal_aux_storage
virtual void timestepSetup() override
ConstElemRange * getActiveLocalElementRange()
Return pointers to range objects for various types of ranges (local nodes, boundary elems...
virtual void clearActiveScalarVariableCoupleableVectorTags(const THREAD_ID tid) override
void computeNodalVarsHelper(const MooseObjectWarehouse< AuxKernelType > &warehouse)
virtual const char * what() const
Get out the error message.
const std::vector< MooseVariableScalar * > & getScalarVariables(THREAD_ID tid)
bool hasActiveBlockObjects(THREAD_ID tid=0) const
void computeScalarVars(ExecFlagType type)
void sort(THREAD_ID tid=0)
Performs a sort using the DependencyResolver.
This class evaluates a single mortar nodal aux kernel.
NumericVector< Number > & solution()
virtual void addVariable(const std::string &var_type, const std::string &var_name, InputParameters ¶meters)
Canonical method for adding a variable.
virtual void augmentSparsity(SparsityPattern::Graph &, std::vector< dof_id_type > &, std::vector< dof_id_type > &) override
Will modify the sparsity pattern to add logical geometric connections.
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
virtual void clearActiveScalarVariableCoupleableMatrixTags(const THREAD_ID tid) override
void updateActive(THREAD_ID tid=0) override
Updates the active objects storage.
virtual void setActiveScalarVariableCoupleableMatrixTags(std::set< TagID > &mtags, const THREAD_ID tid) override
virtual void reinitScalars(const THREAD_ID tid, bool reinit_for_derivative_reordering=false) override
fills the VariableValue arrays for scalar variables from the solution vector
void translateMetaPhysicLError(const MetaPhysicL::LogicError &)
emit a relatively clear error message when we catch a MetaPhysicL logic error
StoredRange< MooseMesh::const_bnd_elem_iterator, const BndElement * > ConstBndElemRange
T * get(const std::unique_ptr< T > &u)
The MooseUtils::get() specializations are used to support making forwards-compatible code changes fro...
AuxiliarySystem(FEProblemBase &subproblem, const std::string &name)
ExecuteMooseObjectWarehouse< ArrayAuxKernel > _nodal_array_aux_storage
std::shared_ptr< MooseObject > create(const std::string &obj_name, const std::string &name, const InputParameters ¶meters, THREAD_ID tid=0, bool print_deprecated=true)
virtual void updateActive(THREAD_ID tid)
virtual void setException(const std::string &message)
Set an exception, which is stored at this point by toggling a member variable in this class...
virtual void customSetup(const ExecFlagType &exec_type, THREAD_ID tid=0) const
void computeElementalVarsHelper(const MooseObjectWarehouse< AuxKernelType > &warehouse)
const Parallel::Communicator & _communicator
Base class for a system (of equations)
ExecuteMooseObjectWarehouse< AuxScalarKernel > _aux_scalar_storage
bool needMaterialOnSide(BoundaryID bnd_id)
Indicated whether this system needs material properties on boundaries.
virtual void reinitElem(const Elem *elem, THREAD_ID tid) override
Reinit an element assembly info.
std::unique_ptr< NumericVector< Number > > _serialized_solution
Serialized version of the solution vector, or nullptr if a serialized solution is not needed...
virtual void residualSetup() override
ConstNodeRange * getLocalNodeRange()
Specialization of SubProblem for solving nonlinear equations plus auxiliary equations.
void computeMortarNodalVars(ExecFlagType type)
MetaPhysicL::DualNumber< V, D, asd > sqrt(const MetaPhysicL::DualNumber< V, D, asd > &a)
virtual unsigned int nVariables() const
Get the number of variables in this system.
bool hasActiveBoundaryObjects(THREAD_ID tid=0) const
virtual const std::string & name() const
virtual void jacobianSetup()
void setScalarVariableCoupleableTags(ExecFlagType type)
void addTimeIntegrator(const std::string &type, const std::string &name, InputParameters ¶meters) override
Add a time integrator.
void clearScalarVariableCoupleableTags()
std::set< std::string > getDependObjects()
virtual void jacobianSetup() override
ExecuteMooseObjectWarehouse< ArrayAuxKernel > _elemental_array_aux_storage
const std::vector< std::shared_ptr< T > > & getActiveObjects(THREAD_ID tid=0) const
Retrieve complete vector to the active all/block/boundary restricted objects for a given thread...
void computeNodalArrayVars(ExecFlagType type)
void computeElementalVars(ExecFlagType type)
Real value(unsigned n, unsigned alpha, unsigned beta, Real x)
virtual void setPreviousNewtonSolution()
Base class for making kernels that work on auxiliary scalar variables.
boundary_id_type BoundaryID
virtual void timestepSetup(THREAD_ID tid=0) const
virtual Order getMinQuadratureOrder() override
Get the minimum quadrature order for evaluating elemental auxiliary variables.
virtual void setActiveScalarVariableCoupleableVectorTags(std::set< TagID > &vtags, const THREAD_ID tid) override
This is a "smart" enum class intended to replace many of the shortcomings in the C++ enum type It sho...
StoredRange< MeshBase::const_node_iterator, const Node *> ConstNodeRange
const ExecFlagType EXEC_LINEAR
virtual void initialSetup(THREAD_ID tid=0) const
Convenience methods for calling object setup methods.
virtual void addVariable(const std::string &var_type, const std::string &name, InputParameters ¶meters) override
Canonical method for adding a variable.
Interface for objects interacting with the PerfGraph.
void jacobianSetup(THREAD_ID tid=0) const override
Convenience methods for calling object setup methods.
const std::map< BoundaryID, std::vector< std::shared_ptr< T > > > & getActiveBoundaryObjects(THREAD_ID tid=0) const
std::vector< std::vector< MooseVariableFEBase * > > _nodal_vars
ExecuteMooseObjectWarehouse< VectorAuxKernel > _nodal_vec_aux_storage
std::vector< std::vector< MooseVariableFieldBase * > > _elem_vars
Elemental variables.
FEProblemBase & _fe_problem
the governing finite element/volume problem
std::vector< VariableWarehouse > _vars
Variable warehouses (one for each thread)
Provides a way for users to bail out of the current solve.
virtual void initialSetup() override
Setup Functions.
Base class for time integrators.
virtual void subdomainSetup()
void addKernel(const std::string &kernel_name, const std::string &name, InputParameters ¶meters)
Adds an auxiliary kernel.
Class for containing MooseEnum item information.
bool hasActiveObjects(THREAD_ID tid=0) const
virtual void compute(ExecFlagType type) override
Compute auxiliary variables.
std::shared_ptr< TimeIntegrator > _time_integrator
Time integrator.
IntRange< T > make_range(T beg, T end)
void computeNodalVars(ExecFlagType type)
virtual void customSetup(const ExecFlagType &exec_type)
void addScalarKernel(const std::string &kernel_name, const std::string &name, InputParameters ¶meters)
Adds a scalar kernel.
virtual void reinitElemFace(const Elem *elem, unsigned int side, BoundaryID bnd_id, THREAD_ID tid) override
Reinit assembly info for a side of an element.
ExecuteMooseObjectWarehouse< AuxKernel > _elemental_aux_storage
virtual void customSetup(const ExecFlagType &exec_type) override
StoredRange< MooseMesh::const_bnd_elem_iterator, const BndElement * > * getBoundaryElementRange()
MOOSE now contains C++17 code, so give a reasonable error message stating what the user can do to add...
virtual void serializeSolution()
void computeNodalVecVars(ExecFlagType type)
StoredRange< MooseMesh::const_bnd_node_iterator, const BndNode * > ConstBndNodeRange
Some useful StoredRange typedefs.
void computeElementalArrayVars(ExecFlagType type)
ExecuteMooseObjectWarehouse< VectorAuxKernel > _elemental_vec_aux_storage
NumericVector< Number > & solutionOld()
virtual void initialSetup()
Setup Functions.
bool defaultGhosting()
Whether or not the user has requested default ghosting ot be on.
virtual Real & dt() const
virtual void residualSetup()
virtual ~AuxiliarySystem()
void residualSetup(THREAD_ID tid=0) const override
virtual void subdomainSetup(THREAD_ID tid=0) const
StoredRange< MooseMesh::const_bnd_node_iterator, const BndNode * > * getBoundaryNodeRange()
auto index_range(const T &sizable)
void variableWiseRelativeSolutionDifferenceNorm(std::vector< Number > &var_diffs) const
Computes and stores ||current - old|| / ||current|| for each variable in the given vector...
void computeElementalVecVars(ExecFlagType type)
virtual void subdomainSetup() override
virtual void timestepSetup()
virtual void localize(std::vector< Number > &v_local) const =0