www.mooseframework.org
NeighborCoupleable.C
Go to the documentation of this file.
1 //* This file is part of the MOOSE framework
2 //* https://www.mooseframework.org
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 "NeighborCoupleable.h"
11 
12 #include "FEProblem.h"
13 #include "MooseError.h" // mooseDeprecated
14 #include "MooseVariableFE.h"
15 #include "Problem.h"
16 #include "SubProblem.h"
17 
19  bool nodal,
20  bool neighbor_nodal,
21  bool is_fv)
22  : Coupleable(moose_object, nodal, is_fv), _neighbor_nodal(neighbor_nodal)
23 {
24 }
25 
26 const VariableValue &
27 NeighborCoupleable::coupledNeighborValue(const std::string & var_name, unsigned int comp) const
28 {
29  const auto * var = getVarHelper<MooseVariableField<Real>>(var_name, comp);
30  if (_neighbor_nodal)
31  return (_c_is_implicit) ? var->dofValuesNeighbor() : var->dofValuesOldNeighbor();
32  else
33  return (_c_is_implicit) ? var->slnNeighbor() : var->slnOldNeighbor();
34 }
35 
36 std::vector<const VariableValue *>
37 NeighborCoupleable::coupledNeighborValues(const std::string & var_name) const
38 {
39  auto func = [this, &var_name](unsigned int comp)
40  { return &coupledNeighborValue(var_name, comp); };
41  return coupledVectorHelper<const VariableValue *>(var_name, func);
42 }
43 
44 std::vector<const VariableValue *>
45 NeighborCoupleable::coupledNeighborValuesOld(const std::string & var_name) const
46 {
47  auto func = [this, &var_name](unsigned int comp)
48  { return &coupledNeighborValueOld(var_name, comp); };
49  return coupledVectorHelper<const VariableValue *>(var_name, func);
50 }
51 
52 std::vector<const VariableValue *>
53 NeighborCoupleable::coupledNeighborValuesOlder(const std::string & var_name) const
54 {
55  auto func = [this, &var_name](unsigned int comp)
56  { return &coupledNeighborValueOlder(var_name, comp); };
57  return coupledVectorHelper<const VariableValue *>(var_name, func);
58 }
59 
60 const ADVariableValue &
61 NeighborCoupleable::adCoupledNeighborValue(const std::string & var_name, unsigned int comp) const
62 {
63  const auto * var = getVarHelper<MooseVariableField<Real>>(var_name, comp);
64 
65  if (!var)
66  return *getADDefaultValue(var_name);
67 
68  if (_neighbor_nodal)
69  mooseError("adCoupledNeighborValue cannot be used for nodal compute objects at this time");
70  if (!_c_is_implicit)
71  mooseError("adCoupledNeighborValue returns a data structure with derivatives. Explicit schemes "
72  "use old solution data which do not have derivatives so adCoupledNeighborValue is "
73  "not appropriate. Please use coupledNeighborValue instead");
74 
75  return var->adSlnNeighbor();
76 }
77 
78 const ADVariableValue &
79 NeighborCoupleable::adCoupledNeighborValueDot(const std::string & var_name, unsigned int comp) const
80 {
81  const auto * var = getVarHelper<MooseVariableField<Real>>(var_name, comp);
82 
83  if (!_c_is_implicit)
84  mooseError(
85  "adCoupledNeighborValueDot returns a data structure with derivatives. Explicit schemes "
86  "use old solution data which do not have derivatives so adCoupledNeighborValueDot is "
87  "not appropriate. Please use coupledNeighborValueDot instead");
88 
89  if (_neighbor_nodal)
90  mooseError("adCoupledNeighborValueDot cannot be used for nodal compute objects at this time");
91  else
92  return var->adUDotNeighbor();
93 }
94 
95 std::vector<const ADVariableValue *>
96 NeighborCoupleable::adCoupledNeighborValues(const std::string & var_name) const
97 {
98  auto func = [this, &var_name](unsigned int comp)
99  { return &adCoupledNeighborValue(var_name, comp); };
100  return coupledVectorHelper<const ADVariableValue *>(var_name, func);
101 }
102 
103 const ADVectorVariableValue &
105  unsigned int comp) const
106 {
107  auto var = getVarHelper<MooseVariableField<RealVectorValue>>(var_name, comp);
108 
109  if (!var)
110  return *getADDefaultVectorValue(var_name);
111 
112  if (_neighbor_nodal)
113  mooseError(
114  "adCoupledVectorNeighborValue cannot be used for nodal compute objects at this time");
115  if (!_c_is_implicit)
116  mooseError(
117  "adCoupledVectorNeighborValue returns a data structure with derivatives. Explicit schemes "
118  "use old solution data which do not have derivatives so adCoupledVectorNeighborValue is "
119  "not appropriate. Please use coupledNeighborValue instead");
120 
121  return var->adSlnNeighbor();
122 }
123 
124 const VariableValue &
125 NeighborCoupleable::coupledNeighborValueDot(const std::string & var_name, unsigned int comp) const
126 {
127  const auto * var = getVar(var_name, comp);
128  if (_neighbor_nodal)
129  return var->dofValuesDotNeighbor();
130  else
131  return var->uDotNeighbor();
132 }
133 
134 const VariableValue &
135 NeighborCoupleable::coupledNeighborValueDotDu(const std::string & var_name, unsigned int comp) const
136 {
137  const auto * var = getVar(var_name, comp);
138  if (_neighbor_nodal)
139  return var->dofValuesDuDotDuNeighbor();
140  else
141  return var->duDotDuNeighbor();
142 }
143 
144 const VariableValue &
145 NeighborCoupleable::coupledNeighborValueOld(const std::string & var_name, unsigned int comp) const
146 {
147  validateExecutionerType(var_name, "coupledNeighborValueOld");
148 
149  const auto * var = getVar(var_name, comp);
150  if (_neighbor_nodal)
151  return (_c_is_implicit) ? var->dofValuesOldNeighbor() : var->dofValuesOlderNeighbor();
152  else
153  return (_c_is_implicit) ? var->slnOldNeighbor() : var->slnOlderNeighbor();
154 }
155 
156 const VariableValue &
157 NeighborCoupleable::coupledNeighborValueOlder(const std::string & var_name, unsigned int comp) const
158 {
159  validateExecutionerType(var_name, "coupledNeighborValueOlder");
160 
161  const auto * var = getVar(var_name, comp);
162  if (_neighbor_nodal)
163  {
164  if (_c_is_implicit)
165  return var->dofValuesOlderNeighbor();
166  else
167  mooseError("Older values not available for explicit schemes");
168  }
169  else
170  {
171  if (_c_is_implicit)
172  return var->slnOlderNeighbor();
173  else
174  mooseError("Older values not available for explicit schemes");
175  }
176 }
177 
178 const VariableGradient &
179 NeighborCoupleable::coupledNeighborGradient(const std::string & var_name, unsigned int comp) const
180 {
181  if (_neighbor_nodal)
182  mooseError("Nodal variables do not have gradients");
183 
184  const auto * var = getVarHelper<MooseVariableField<Real>>(var_name, comp);
185  return (_c_is_implicit) ? var->gradSlnNeighbor() : var->gradSlnOldNeighbor();
186 }
187 
188 std::vector<const VariableGradient *>
189 NeighborCoupleable::coupledNeighborGradients(const std::string & var_name) const
190 {
191  auto func = [this, &var_name](unsigned int comp)
192  { return &coupledNeighborGradient(var_name, comp); };
193  return coupledVectorHelper<const VariableGradient *>(var_name, func);
194 }
195 
196 const VariableGradient &
198  unsigned int comp) const
199 {
200  if (_neighbor_nodal)
201  mooseError("Nodal variables do not have gradients");
202 
203  validateExecutionerType(var_name, "coupledNeighborGradientOld");
204  const auto * var = getVar(var_name, comp);
205  return (_c_is_implicit) ? var->gradSlnOldNeighbor() : var->gradSlnOlderNeighbor();
206 }
207 
208 const VariableGradient &
210  unsigned int comp) const
211 {
212  if (_neighbor_nodal)
213  mooseError("Nodal variables do not have gradients");
214 
215  validateExecutionerType(var_name, "coupledNeighborGradientOlder");
216  const auto * var = getVar(var_name, comp);
217  if (_c_is_implicit)
218  return var->gradSlnOlderNeighbor();
219  else
220  mooseError("Older values not available for explicit schemes");
221 }
222 
223 const ADVariableGradient &
224 NeighborCoupleable::adCoupledNeighborGradient(const std::string & var_name, unsigned int comp) const
225 {
226  if (_neighbor_nodal)
227  mooseError("Nodal variables do not have gradients");
228  if (!_c_is_implicit)
229  mooseError(
230  "adCoupledNeighborGradient returns a data structure with derivatives. Explicit schemes "
231  "use old solution data which do not have derivatives so adCoupledNeighborGradient is "
232  "not appropriate. Please use coupledNeighborGradient instead");
233 
234  const auto * var = getVarHelper<MooseVariableField<Real>>(var_name, comp);
235  return var->adGradSlnNeighbor();
236 }
237 
240  unsigned int comp) const
241 {
242  if (_neighbor_nodal)
243  mooseError("Gradients are non-sensical with nodal compute objects");
244 
245  const auto * var = getVectorVar(var_name, comp);
246  return (_c_is_implicit) ? var->gradSlnNeighbor() : var->gradSlnOldNeighbor();
247 }
248 
251  unsigned int comp) const
252 {
253  if (_neighbor_nodal)
254  mooseError("Gradients are non-sensical with nodal compute objects");
255 
256  validateExecutionerType(var_name, "coupledVectorNeighborGradientOld");
257  const auto * var = getVectorVar(var_name, comp);
258  return (_c_is_implicit) ? var->gradSlnOldNeighbor() : var->gradSlnOlderNeighbor();
259 }
260 
263  unsigned int comp) const
264 {
265  if (_neighbor_nodal)
266  mooseError("Gradients are non-sensical with nodal compute objects");
267 
268  validateExecutionerType(var_name, "coupledVectorNeighborGradientOlder");
269  const auto * var = getVectorVar(var_name, comp);
270  if (_c_is_implicit)
271  return var->gradSlnOlderNeighbor();
272  else
273  mooseError("Older values not available for explicit schemes");
274 }
275 
276 const ArrayVariableValue &
277 NeighborCoupleable::coupledArrayNeighborValue(const std::string & var_name, unsigned int comp) const
278 {
279  const auto * var = getArrayVar(var_name, comp);
280  if (_neighbor_nodal)
281  return (_c_is_implicit) ? var->dofValuesNeighbor() : var->dofValuesOldNeighbor();
282  else
283  return (_c_is_implicit) ? var->slnNeighbor() : var->slnOldNeighbor();
284 }
285 
286 const ArrayVariableGradient &
288  unsigned int comp) const
289 {
290  if (_neighbor_nodal)
291  mooseError("Gradients are non-sensical with nodal compute objects");
292 
293  const auto * var = getArrayVar(var_name, comp);
294  return (_c_is_implicit) ? var->gradSlnNeighbor() : var->gradSlnOldNeighbor();
295 }
296 
297 const ArrayVariableGradient &
299  unsigned int comp) const
300 {
301  if (_neighbor_nodal)
302  mooseError("Gradients are non-sensical with nodal compute objects");
303 
304  validateExecutionerType(var_name, "coupledArrayNeighborGradientOld");
305  const auto * var = getArrayVar(var_name, comp);
306  return (_c_is_implicit) ? var->gradSlnOldNeighbor() : var->gradSlnOlderNeighbor();
307 }
308 
309 const ArrayVariableGradient &
311  unsigned int comp) const
312 {
313  if (_neighbor_nodal)
314  mooseError("Gradients are non-sensical with nodal compute objects");
315 
316  validateExecutionerType(var_name, "coupledArrayNeighborGradientOlder");
317  const auto * var = getArrayVar(var_name, comp);
318  if (_c_is_implicit)
319  return var->gradSlnOlderNeighbor();
320  else
321  mooseError("Older values not available for explicit schemes");
322 }
323 
324 const VariableSecond &
325 NeighborCoupleable::coupledNeighborSecond(const std::string & var_name, unsigned int comp) const
326 {
327  if (_neighbor_nodal)
328  mooseError("Nodal variables do not have second derivatives");
329 
330  const auto * var = getVar(var_name, comp);
331  return (_c_is_implicit) ? var->secondSlnNeighbor() : var->secondSlnOldNeighbor();
332 }
333 
334 const VariableValue &
335 NeighborCoupleable::coupledNeighborDofValues(const std::string & var_name, unsigned int comp) const
336 {
337  if (_neighbor_nodal)
338  mooseError("nodal objects should not call coupledDofValues");
339 
340  const auto * var = getVar(var_name, comp);
341  return (_c_is_implicit) ? var->dofValuesNeighbor() : var->dofValuesOldNeighbor();
342 }
343 
344 const VariableValue &
346  unsigned int comp) const
347 {
348  if (_neighbor_nodal)
349  mooseError("nodal objects should not call coupledDofValuesOld");
350 
351  validateExecutionerType(var_name, "coupledNeighborDofValuesOld");
352  const auto * var = getVar(var_name, comp);
353  return (_c_is_implicit) ? var->dofValuesOldNeighbor() : var->dofValuesOlderNeighbor();
354 }
355 
356 const VariableValue &
358  unsigned int comp) const
359 {
360  if (_neighbor_nodal)
361  mooseError("nodal objects should not call coupledDofValuesOlder");
362 
363  validateExecutionerType(var_name, "coupledNeighborDofValuesOlder");
364  const auto * var = getVar(var_name, comp);
365  if (_c_is_implicit)
366  return var->dofValuesOlderNeighbor();
367  else
368  mooseError("Older values not available for explicit schemes");
369 }
OutputTools< Real >::VariableGradient VariableGradient
Definition: MooseTypes.h:303
void validateExecutionerType(const std::string &name, const std::string &fn_name) const
Checks to make sure that the current Executioner has set "_is_transient" when old/older values are co...
Definition: Coupleable.C:2017
virtual const VectorVariableGradient & coupledVectorNeighborGradientOld(const std::string &var_name, unsigned int comp=0) const
VectorMooseVariable * getVectorVar(const std::string &var_name, unsigned int comp)
Extract pointer to a coupled vector variable.
Definition: Coupleable.C:289
virtual const VectorVariableGradient & coupledVectorNeighborGradient(const std::string &var_name, unsigned int comp=0) const
virtual const ADVariableGradient & adCoupledNeighborGradient(const std::string &var_name, unsigned int comp=0) const
Get the coupled neighbor variable gradient for var_name with derivative information for automatic dif...
const ADVectorVariableValue * getADDefaultVectorValue(const std::string &var_name) const
Helper method to return (and insert if necessary) the default vector value for Automatic Differentiat...
Definition: Coupleable.C:2248
virtual std::vector< const VariableGradient * > coupledNeighborGradients(const std::string &var_name) const
virtual const VectorVariableGradient & coupledVectorNeighborGradientOlder(const std::string &var_name, unsigned int comp=0) const
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:284
virtual const VariableGradient & coupledNeighborGradient(const std::string &var_name, unsigned int comp=0) const
std::vector< const VariableValue * > coupledNeighborValuesOld(const std::string &var_name) const
virtual const VariableValue & coupledNeighborValueOlder(const std::string &var_name, unsigned int comp=0) const
virtual const VariableValue & coupledNeighborDofValuesOld(const std::string &var_name, unsigned int comp=0) const
virtual const VariableGradient & coupledNeighborGradientOld(const std::string &var_name, unsigned int comp=0) const
MooseVariable * getVar(const std::string &var_name, unsigned int comp)
Extract pointer to a coupled variable.
Definition: Coupleable.C:283
virtual const ArrayVariableValue & coupledArrayNeighborValue(const std::string &var_name, unsigned int comp=0) const
bool _c_is_implicit
True if implicit value is required.
Definition: Coupleable.h:1348
virtual const ArrayVariableGradient & coupledArrayNeighborGradientOlder(const std::string &var_name, unsigned int comp=0) const
OutputTools< RealEigenVector >::VariableValue ArrayVariableValue
Definition: MooseTypes.h:336
virtual const ADVectorVariableValue & adCoupledVectorNeighborValue(const std::string &var_name, unsigned int comp=0) const
Get the coupled neighbor vector variable value for var_name with derivative information for automatic...
virtual const VariableValue & coupledNeighborValue(const std::string &var_name, unsigned int comp=0) const
Every object that can be built by the factory should be derived from this class.
Definition: MooseObject.h:33
std::vector< const VariableValue * > coupledNeighborValuesOlder(const std::string &var_name) const
virtual const VariableValue & coupledNeighborValueDotDu(const std::string &var_name, unsigned int comp=0) const
const ADVariableValue * getADDefaultValue(const std::string &var_name) const
Helper method to return (and insert if necessary) the default value for Automatic Differentiation for...
Definition: Coupleable.C:2234
std::vector< const ADVariableValue * > adCoupledNeighborValues(const std::string &var_name) const
virtual const VariableGradient & coupledNeighborGradientOlder(const std::string &var_name, unsigned int comp=0) const
virtual const ADVariableValue & adCoupledNeighborValue(const std::string &var_name, unsigned int comp=0) const
Get the coupled neighbor variable value for var_name with derivative information for automatic differ...
virtual const ArrayVariableGradient & coupledArrayNeighborGradient(const std::string &var_name, unsigned int comp=0) const
OutputTools< Real >::VariableValue VariableValue
Definition: MooseTypes.h:302
Interface for objects that needs coupling capabilities.
Definition: Coupleable.h:44
NeighborCoupleable(const MooseObject *moose_object, bool nodal, bool neighbor_nodal, bool is_fv=false)
Constructing the object.
virtual const ArrayVariableGradient & coupledArrayNeighborGradientOld(const std::string &var_name, unsigned int comp=0) const
virtual const ADVariableValue & adCoupledNeighborValueDot(const std::string &var_name, unsigned int comp=0) const
Get the time derivative of the coupled neighbor variable value for var_name with derivative informati...
virtual const VariableValue & coupledNeighborValueDot(const std::string &var_name, unsigned int comp=0) const
virtual const VariableValue & coupledNeighborDofValuesOlder(const std::string &var_name, unsigned int comp=0) const
ArrayMooseVariable * getArrayVar(const std::string &var_name, unsigned int comp)
Extract pointer to a coupled array variable.
Definition: Coupleable.C:301
virtual const VariableValue & coupledNeighborDofValues(const std::string &var_name, unsigned int comp=0) const
OutputTools< Real >::VariableSecond VariableSecond
Definition: MooseTypes.h:304
virtual const VariableValue & coupledNeighborValueOld(const std::string &var_name, unsigned int comp=0) const
OutputTools< RealVectorValue >::VariableGradient VectorVariableGradient
Definition: MooseTypes.h:320
OutputTools< RealEigenVector >::VariableGradient ArrayVariableGradient
Definition: MooseTypes.h:337
std::vector< const VariableValue * > coupledNeighborValues(const std::string &var_name) const
virtual const VariableSecond & coupledNeighborSecond(const std::string &var_name, unsigned int i=0) const