Line data Source code
1 : //* This file is part of the MOOSE framework
2 : //* https://mooseframework.inl.gov
3 : //*
4 : //* All rights reserved, see COPYRIGHT for full restrictions
5 : //* https://github.com/idaholab/moose/blob/master/COPYRIGHT
6 : //*
7 : //* Licensed under LGPL 2.1, please see LICENSE for details
8 : //* https://www.gnu.org/licenses/lgpl-2.1.html
9 :
10 : #include "AuxKernelBase.h"
11 :
12 : // local includes
13 : #include "FEProblem.h"
14 : #include "SubProblem.h"
15 : #include "AuxiliarySystem.h"
16 : #include "MooseTypes.h"
17 : #include "Assembly.h"
18 :
19 : InputParameters
20 609312 : AuxKernelBase::validParams()
21 : {
22 609312 : InputParameters params = MooseObject::validParams();
23 609312 : params += BlockRestrictable::validParams();
24 609312 : params += BoundaryRestrictable::validParams();
25 609312 : params += RandomInterface::validParams();
26 609312 : params += MeshChangedInterface::validParams();
27 609312 : params += MaterialPropertyInterface::validParams();
28 609312 : params += FunctorInterface::validParams();
29 609312 : params += GeometricSearchInterface::validParams();
30 :
31 : // Add the SetupInterface parameter 'execute_on' with 'linear' and 'timestep_end'
32 609312 : params += SetupInterface::validParams();
33 609312 : ExecFlagEnum & exec_enum = params.set<ExecFlagEnum>("execute_on", true);
34 609312 : exec_enum.addAvailableFlags(EXEC_PRE_DISPLACE);
35 1827936 : exec_enum = {EXEC_LINEAR, EXEC_TIMESTEP_END};
36 1827936 : params.setDocString("execute_on", exec_enum.getDocString());
37 :
38 2437248 : params.addRequiredParam<AuxVariableName>("variable",
39 : "The name of the variable that this object applies to");
40 :
41 1827936 : params.addParam<bool>("use_displaced_mesh",
42 1218624 : false,
43 : "Whether or not this object should use the "
44 : "displaced mesh for computation. Note that "
45 : "in the case this is true but no "
46 : "displacements are provided in the Mesh block "
47 : "the undisplaced mesh will still be used.");
48 2437248 : params.addParamNamesToGroup("use_displaced_mesh", "Advanced");
49 1218624 : params.addParam<bool>("check_boundary_restricted",
50 1218624 : true,
51 : "Whether to check for multiple element sides on the boundary "
52 : "in the case of a boundary restricted, element aux variable. "
53 : "Setting this to false will allow contribution to a single element's "
54 : "elemental value(s) from multiple boundary sides on the same element "
55 : "(example: when the restricted boundary exists on two or more sides "
56 : "of an element, such as at a corner of a mesh");
57 :
58 1827936 : params.addRelationshipManager("GhostLowerDElems",
59 : Moose::RelationshipManagerType::GEOMETRIC |
60 : Moose::RelationshipManagerType::ALGEBRAIC);
61 :
62 1827936 : params.declareControllable("enable"); // allows Control to enable/disable this type of object
63 :
64 609312 : params.registerBase("AuxKernel");
65 :
66 609312 : return params;
67 609312 : }
68 :
69 71577 : AuxKernelBase::AuxKernelBase(const InputParameters & parameters)
70 : : MooseObject(parameters),
71 : BlockRestrictable(this),
72 71574 : BoundaryRestrictable(this, getVariableHelper(parameters).isNodal()),
73 : SetupInterface(this),
74 : CoupleableMooseVariableDependencyIntermediateInterface(this,
75 71574 : getVariableHelper(parameters).isNodal()),
76 : FunctionInterface(this),
77 : UserObjectInterface(this),
78 : TransientInterface(this),
79 : MaterialPropertyInterface(this, blockIDs(), boundaryIDs()),
80 : PostprocessorInterface(this),
81 : DependencyResolverInterface(),
82 : RandomInterface(parameters,
83 286296 : *parameters.getCheckedPointerParam<FEProblemBase *>("_fe_problem_base"),
84 71574 : parameters.get<THREAD_ID>("_tid"),
85 71574 : getVariableHelper(parameters).isNodal()),
86 : GeometricSearchInterface(this),
87 : Restartable(this, "AuxKernels"),
88 : MeshChangedInterface(parameters),
89 : VectorPostprocessorInterface(this),
90 : ElementIDInterface(this),
91 : NonADFunctorInterface(this),
92 :
93 143148 : _var(getVariableHelper(parameters)),
94 71574 : _bnd(boundaryRestricted()),
95 143148 : _check_boundary_restricted(getParam<bool>("check_boundary_restricted")),
96 286296 : _subproblem(*getCheckedPointerParam<SubProblem *>("_subproblem")),
97 286296 : _sys(*getCheckedPointerParam<SystemBase *>("_sys")),
98 286296 : _nl_sys(*getCheckedPointerParam<SystemBase *>("_nl_sys")),
99 71574 : _aux_sys(static_cast<AuxiliarySystem &>(_sys)),
100 71574 : _tid(parameters.get<THREAD_ID>("_tid")),
101 71574 : _assembly(_subproblem.assembly(_tid, 0)),
102 715743 : _mesh(_subproblem.mesh())
103 : {
104 : // Propagation of the aux kernel value into the auxiliary system must go through a presized
105 : // MooseArray that is only properfly sized for FV variables if we're doing "qp" calculations. I'm
106 : // quoting "qp" because it's a briefer metaphorical representation (perhaps not a good one) of the
107 : // more precise requirement that variable data be pre-sized/operator[] indexable
108 71574 : _var.requireQpComputations();
109 :
110 71574 : addMooseVariableDependency(&_var);
111 71574 : _supplied_vars.insert(parameters.get<AuxVariableName>("variable"));
112 :
113 : // Check for supported variable types
114 : // Any 'nodal' family that actually has DoFs outside of nodes, or gradient dofs at nodes is
115 : // not properly set by AuxKernelTempl::compute
116 : // NOTE: We could add a few exceptions, lower order from certain unsupported families and on
117 : // certain element types only have value-DoFs on nodes
118 71574 : const auto type = _var.feType();
119 71574 : if (_var.isNodal() && !((type.family == LAGRANGE) || (type.order <= FIRST)))
120 0 : paramError("variable",
121 0 : "Variable family " + Moose::stringify(type.family) + " is not supported at order " +
122 0 : Moose::stringify(type.order) + " by the AuxKernel system.");
123 71574 : }
124 :
125 : #ifdef MOOSE_KOKKOS_ENABLED
126 25532 : AuxKernelBase::AuxKernelBase(const AuxKernelBase & object, const Moose::Kokkos::FunctorCopy & key)
127 : : MooseObject(object, key),
128 : BlockRestrictable(object, key),
129 : BoundaryRestrictable(object, key),
130 : SetupInterface(object, key),
131 : CoupleableMooseVariableDependencyIntermediateInterface(object, key),
132 : FunctionInterface(object, key),
133 : UserObjectInterface(object, key),
134 : TransientInterface(object, key),
135 : MaterialPropertyInterface(object, key),
136 : PostprocessorInterface(object, key),
137 : DependencyResolverInterface(object, key),
138 : RandomInterface(object, key),
139 : GeometricSearchInterface(object, key),
140 : Restartable(object, key),
141 : MeshChangedInterface(object, key),
142 : VectorPostprocessorInterface(object, key),
143 : ElementIDInterface(object, key),
144 : NonADFunctorInterface(object, key),
145 :
146 25532 : _var(object._var),
147 25532 : _bnd(object._bnd),
148 25532 : _check_boundary_restricted(object._check_boundary_restricted),
149 25532 : _subproblem(object._subproblem),
150 25532 : _sys(object._sys),
151 25532 : _nl_sys(object._nl_sys),
152 25532 : _aux_sys(object._aux_sys),
153 25532 : _tid(object._tid),
154 25532 : _assembly(object._assembly),
155 25532 : _mesh(object._mesh)
156 : {
157 25532 : }
158 : #endif
159 :
160 : void
161 68923 : AuxKernelBase::initialSetup()
162 : {
163 : // This check must occur after the EquationSystems object has been init'd (due to calls to
164 : // Elem::n_dofs()) so we can't do it in the constructor
165 68923 : if (_bnd && !_var.isNodal() && _check_boundary_restricted)
166 : {
167 : // when the variable is elemental and this aux kernel operates on boundaries,
168 : // we need to check that no elements are visited more than once through visiting
169 : // all the sides on the boundaries
170 1339 : auto boundaries = _mesh.getMesh().get_boundary_info().build_side_list();
171 1339 : std::set<dof_id_type> element_ids;
172 173462 : for (const auto & [elem_id, _, boundary_id] : boundaries)
173 : {
174 172126 : if (hasBoundary(boundary_id) && _mesh.elemPtr(elem_id)->n_dofs(_sys.number(), _var.number()))
175 : {
176 63169 : const auto [_, inserted] = element_ids.insert(elem_id);
177 63169 : if (!inserted) // already existed in the set
178 3 : mooseError(
179 : "Boundary restricted auxiliary kernel '",
180 3 : name(),
181 : "' has element (id=",
182 : elem_id,
183 : ") connected with more than one boundary sides.\nTo skip this error check, "
184 : "set 'check_boundary_restricted = false'.\nRefer to the AuxKernel "
185 : "documentation on boundary restricted aux kernels for understanding this error.");
186 : }
187 : }
188 1336 : }
189 68920 : }
190 :
191 : const std::set<std::string> &
192 233097 : AuxKernelBase::getRequestedItems()
193 : {
194 233097 : return _depend_vars;
195 : }
196 :
197 : const std::set<std::string> &
198 233097 : AuxKernelBase::getSuppliedItems()
199 : {
200 233097 : return _supplied_vars;
201 : }
202 :
203 : void
204 8890 : AuxKernelBase::coupledCallback(const std::string & var_name, bool is_old) const
205 : {
206 8890 : if (!is_old)
207 : {
208 8675 : const auto & var_names = getParam<std::vector<VariableName>>(var_name);
209 8675 : _depend_vars.insert(var_names.begin(), var_names.end());
210 : }
211 8890 : }
212 :
213 : void
214 5126 : AuxKernelBase::addUserObjectDependencyHelper(const UserObjectBase & uo) const
215 : {
216 5126 : _depend_uo.insert(uo.name());
217 5199 : for (const auto & indirect_dependent : uo.getDependObjects())
218 5199 : _depend_uo.insert(indirect_dependent);
219 5126 : }
220 :
221 : void
222 222 : AuxKernelBase::addPostprocessorDependencyHelper(const PostprocessorName & name) const
223 : {
224 222 : getUserObjectBaseByName(name); // getting the UO will call addUserObjectDependencyHelper()
225 222 : }
226 :
227 : void
228 227 : AuxKernelBase::addVectorPostprocessorDependencyHelper(const VectorPostprocessorName & name) const
229 : {
230 227 : getUserObjectBaseByName(name); // getting the UO will call addUserObjectDependencyHelper()
231 227 : }
232 :
233 : MooseVariableFieldBase &
234 286299 : AuxKernelBase::getVariableHelper(const InputParameters & parameters)
235 : {
236 1145190 : return parameters.getCheckedPointerParam<SystemBase *>("_sys")->getVariable(
237 572595 : parameters.get<THREAD_ID>("_tid"), parameters.get<AuxVariableName>("variable"));
238 : }
|
