www.mooseframework.org
Public Member Functions | Protected Member Functions | Protected Attributes | Private Member Functions | Private Attributes | List of all members
Coupleable Class Reference

Interface for objects that needs coupling capabilities. More...

#include <Coupleable.h>

Inheritance diagram for Coupleable:
[legend]

Public Member Functions

 Coupleable (const MooseObject *moose_object, bool nodal)
 Constructing the object. More...
 
virtual ~Coupleable ()
 Destructor for object. More...
 
const std::map< std::string, std::vector< MooseVariable * > > & getCoupledVars ()
 Get the list of coupled variables. More...
 
const std::vector< MooseVariable * > & getCoupledMooseVars () const
 Get the list of coupled variables. More...
 

Protected Member Functions

virtual bool isCoupled (const std::string &var_name, unsigned int i=0)
 Returns true if a variables has been coupled as name. More...
 
unsigned int coupledComponents (const std::string &var_name)
 Number of coupled components. More...
 
virtual void coupledCallback (const std::string &var_name, bool is_old)
 
virtual unsigned int coupled (const std::string &var_name, unsigned int comp=0)
 Returns the index for a coupled variable by name. More...
 
virtual const VariableValuecoupledValue (const std::string &var_name, unsigned int comp=0)
 Returns value of a coupled variable. More...
 
virtual VariableValuewritableCoupledValue (const std::string &var_name, unsigned int comp=0)
 Returns a writable reference to a coupled variable. More...
 
virtual const VariableValuecoupledValueOld (const std::string &var_name, unsigned int comp=0)
 Returns an old value from previous time step of a coupled variable. More...
 
virtual const VariableValuecoupledValueOlder (const std::string &var_name, unsigned int comp=0)
 Returns an old value from two time steps previous of a coupled variable. More...
 
virtual const VariableValuecoupledValuePreviousNL (const std::string &var_name, unsigned int comp=0)
 Returns value of previous Newton iterate of a coupled variable. More...
 
virtual const VariableGradientcoupledGradient (const std::string &var_name, unsigned int comp=0)
 Returns gradient of a coupled variable. More...
 
virtual const VariableGradientcoupledGradientOld (const std::string &var_name, unsigned int comp=0)
 Returns an old gradient from previous time step of a coupled variable. More...
 
virtual const VariableGradientcoupledGradientOlder (const std::string &var_name, unsigned int comp=0)
 Returns an old gradient from two time steps previous of a coupled variable. More...
 
virtual const VariableGradientcoupledGradientPreviousNL (const std::string &var_name, unsigned int comp=0)
 Returns gradient of a coupled variable for previous Newton iterate. More...
 
virtual const VariableSecondcoupledSecond (const std::string &var_name, unsigned int comp=0)
 Returns second derivative of a coupled variable. More...
 
virtual const VariableSecondcoupledSecondOld (const std::string &var_name, unsigned int comp=0)
 Returns an old second derivative from previous time step of a coupled variable. More...
 
virtual const VariableSecondcoupledSecondOlder (const std::string &var_name, unsigned int comp=0)
 Returns an old second derivative from two time steps previous of a coupled variable. More...
 
virtual const VariableSecondcoupledSecondPreviousNL (const std::string &var_name, unsigned int comp=0)
 Returns second derivative of a coupled variable for the previous Newton iterate. More...
 
virtual const VariableValuecoupledDot (const std::string &var_name, unsigned int comp=0)
 Time derivative of a coupled variable. More...
 
virtual const VariableValuecoupledDotDu (const std::string &var_name, unsigned int comp=0)
 Time derivative of a coupled variable with respect to the coefficients. More...
 
virtual const VariableValuecoupledNodalValue (const std::string &var_name, unsigned int comp=0)
 Returns nodal values of a coupled variable. More...
 
virtual const VariableValuecoupledNodalValueOld (const std::string &var_name, unsigned int comp=0)
 Returns an old nodal value from previous time step of a coupled variable. More...
 
virtual const VariableValuecoupledNodalValueOlder (const std::string &var_name, unsigned int comp=0)
 Returns an old nodal value from two time steps previous of a coupled variable. More...
 
virtual const VariableValuecoupledNodalValuePreviousNL (const std::string &var_name, unsigned int comp=0)
 Returns nodal values of a coupled variable for previous Newton iterate. More...
 
virtual const VariableValuecoupledNodalDot (const std::string &var_name, unsigned int comp=0)
 Nodal values of time derivative of a coupled variable. More...
 
virtual const DenseVector< Number > & coupledSolutionDoFs (const std::string &var_name, unsigned int comp=0)
 Returns DoFs in the current solution vector of a coupled variable for the local element. More...
 
virtual const DenseVector< Number > & coupledSolutionDoFsOld (const std::string &var_name, unsigned int comp=0)
 Returns DoFs in the old solution vector of a coupled variable for the local element. More...
 
virtual const DenseVector< Number > & coupledSolutionDoFsOlder (const std::string &var_name, unsigned int comp=0)
 Returns DoFs in the older solution vector of a coupled variable for the local element. More...
 
MooseVariablegetVar (const std::string &var_name, unsigned int comp)
 Extract pointer to a coupled variable. More...
 
void validateExecutionerType (const std::string &name) const
 Checks to make sure that the current Executioner has set "_it_transient" when old/older values are coupled in. More...
 

Protected Attributes

const InputParameters_c_parameters
 
FEProblemBase_c_fe_problem
 
std::map< std::string, std::vector< MooseVariable * > > _coupled_vars
 Coupled vars whose values we provide. More...
 
std::vector< MooseVariable * > _coupled_moose_vars
 Vector of coupled variables. More...
 
bool _c_nodal
 True if we provide coupling to nodal values. More...
 
bool _c_is_implicit
 True if implicit value is required. More...
 
const InputParameters_coupleable_params
 Local InputParameters. More...
 
std::map< std::string, VariableValue * > _default_value
 Will hold the default value for optional coupled variables. More...
 
VariableValue _default_value_zero
 This will always be zero because the default values for optionally coupled variables is always constant and this is used for time derivative info. More...
 
VariableGradient _default_gradient
 This will always be zero because the default values for optionally coupled variables is always constant. More...
 
VariableSecond _default_second
 This will always be zero because the default values for optionally coupled variables is always constant. More...
 
bool _coupleable_neighbor
 Whether or not this object is a "neighbor" object: ie all of it's coupled values should be neighbor values. More...
 

Private Member Functions

VariableValuegetDefaultValue (const std::string &var_name)
 Helper method to return (and insert if necessary) the default value for an uncoupled variable. More...
 

Private Attributes

unsigned int _coupleable_max_qps
 Maximum qps for any element in this system. More...
 
std::map< std::string, unsigned int > _optional_var_index
 Unique indices for optionally coupled vars that weren't provided. More...
 

Detailed Description

Interface for objects that needs coupling capabilities.

Definition at line 35 of file Coupleable.h.

Constructor & Destructor Documentation

Coupleable::Coupleable ( const MooseObject moose_object,
bool  nodal 
)

Constructing the object.

Parameters
parametersParameters that come from constructing the object
nodaltrue if we need to couple with nodal values, otherwise false

Definition at line 23 of file Coupleable.C.

24  : _c_parameters(moose_object->parameters()),
26  _c_nodal(nodal),
27  _c_is_implicit(_c_parameters.have_parameter<bool>("implicit")
28  ? _c_parameters.get<bool>("implicit")
29  : true),
31  _coupleable_neighbor(_c_parameters.have_parameter<bool>("_neighbor")
32  ? _c_parameters.get<bool>("_neighbor")
33  : false),
35 {
36  SubProblem & problem = *_c_parameters.get<SubProblem *>("_subproblem");
37 
38  THREAD_ID tid = _c_parameters.get<THREAD_ID>("_tid");
39 
40  // Coupling
41  for (std::set<std::string>::const_iterator iter = _c_parameters.coupledVarsBegin();
42  iter != _c_parameters.coupledVarsEnd();
43  ++iter)
44  {
45  std::string name = *iter;
46  if (_c_parameters.getVecMooseType(name) != std::vector<std::string>())
47  {
48  std::vector<std::string> vars = _c_parameters.getVecMooseType(*iter);
49  for (const auto & coupled_var_name : vars)
50  {
51  if (problem.hasVariable(coupled_var_name))
52  {
53  MooseVariable * moose_var = &problem.getVariable(tid, coupled_var_name);
54  _coupled_vars[name].push_back(moose_var);
55  _coupled_moose_vars.push_back(moose_var);
56  }
57  else if (problem.hasScalarVariable(coupled_var_name))
58  ; // ignore scalar variables
59  else
60  mooseError("Coupled variable '" + coupled_var_name + "' was not found\n");
61  }
62  }
63  else // This means it was optional coupling. Let's assign a unique id to this variable
64  _optional_var_index[name] =
65  std::numeric_limits<unsigned int>::max() - _optional_var_index.size();
66  }
67 
71 }
virtual bool hasVariable(const std::string &var_name)=0
bool _c_nodal
True if we provide coupling to nodal values.
Definition: Coupleable.h:327
std::vector< MooseVariable * > _coupled_moose_vars
Vector of coupled variables.
Definition: Coupleable.h:324
Class for stuff related to variables.
Definition: MooseVariable.h:43
std::set< std::string >::const_iterator coupledVarsEnd() const
virtual MooseVariable & getVariable(THREAD_ID tid, const std::string &var_name)=0
Returns the variable reference for requested variable which may be in any system. ...
void resize(const unsigned int size)
Change the number of elements the array can store.
Definition: MooseArray.h:205
std::vector< std::string > getVecMooseType(const std::string &name) const
void mooseError(Args &&...args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:182
VariableValue _default_value_zero
This will always be zero because the default values for optionally coupled variables is always consta...
Definition: Coupleable.h:339
Specialization of SubProblem for solving nonlinear equations plus auxiliary equations.
std::map< std::string, std::vector< MooseVariable * > > _coupled_vars
Coupled vars whose values we provide.
Definition: Coupleable.h:321
FEProblemBase & _c_fe_problem
Definition: Coupleable.h:318
bool _c_is_implicit
True if implicit value is required.
Definition: Coupleable.h:330
unsigned int getMaxQps() const
T getCheckedPointerParam(const std::string &name, const std::string &error_string="") const
Verifies that the requested parameter exists and is not NULL and returns it to the caller...
VariableGradient _default_gradient
This will always be zero because the default values for optionally coupled variables is always consta...
Definition: Coupleable.h:342
VariableSecond _default_second
This will always be zero because the default values for optionally coupled variables is always consta...
Definition: Coupleable.h:345
const InputParameters & _coupleable_params
Local InputParameters.
Definition: Coupleable.h:333
bool _coupleable_neighbor
Whether or not this object is a "neighbor" object: ie all of it&#39;s coupled values should be neighbor v...
Definition: Coupleable.h:363
Generic class for solving transient nonlinear problems.
Definition: SubProblem.h:53
const InputParameters & parameters() const
Get the parameters of the object.
Definition: MooseObject.h:53
std::set< std::string >::const_iterator coupledVarsBegin() const
Methods returning iterators to the coupled variables names stored in this InputParameters object...
const InputParameters & _c_parameters
Definition: Coupleable.h:315
std::map< std::string, unsigned int > _optional_var_index
Unique indices for optionally coupled vars that weren&#39;t provided.
Definition: Coupleable.h:378
virtual bool hasScalarVariable(const std::string &var_name)=0
Returns a Boolean indicating whether any system contains a variable with the name provided...
unsigned int _coupleable_max_qps
Maximum qps for any element in this system.
Definition: Coupleable.h:375
unsigned int THREAD_ID
Definition: MooseTypes.h:79
Coupleable::~Coupleable ( )
virtual

Destructor for object.

Definition at line 73 of file Coupleable.C.

74 {
75  for (auto & it : _default_value)
76  {
77  it.second->release();
78  delete it.second;
79  }
83 }
VariableValue _default_value_zero
This will always be zero because the default values for optionally coupled variables is always consta...
Definition: Coupleable.h:339
VariableGradient _default_gradient
This will always be zero because the default values for optionally coupled variables is always consta...
Definition: Coupleable.h:342
VariableSecond _default_second
This will always be zero because the default values for optionally coupled variables is always consta...
Definition: Coupleable.h:345
void release()
Manually deallocates the data pointer.
Definition: MooseArray.h:56
std::map< std::string, VariableValue * > _default_value
Will hold the default value for optional coupled variables.
Definition: Coupleable.h:336

Member Function Documentation

unsigned int Coupleable::coupled ( const std::string &  var_name,
unsigned int  comp = 0 
)
protectedvirtual

Returns the index for a coupled variable by name.

Parameters
var_nameName of coupled variable
compComponent number for vector of coupled variables
Returns
Index of coupled variable, if this is an optionally coupled variable that wasn't provided this will return a unique "invalid" index.

Reimplemented in ShapeUserObject< ElementUserObject >, and ShapeUserObject< SideUserObject >.

Definition at line 136 of file Coupleable.C.

Referenced by NodalEqualValueConstraint::NodalEqualValueConstraint().

137 {
138  if (!isCoupled(var_name))
139  return _optional_var_index[var_name];
140 
141  MooseVariable * var = getVar(var_name, comp);
142  switch (var->kind())
143  {
145  return var->number();
147  return std::numeric_limits<unsigned int>::max() - var->number();
148  }
149  mooseError("Unknown variable kind. Corrupted binary?");
150 }
Class for stuff related to variables.
Definition: MooseVariable.h:43
Moose::VarKindType kind() const
Kind of the variable (Nonlinear, Auxiliary, ...)
void mooseError(Args &&...args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:182
MooseVariable * getVar(const std::string &var_name, unsigned int comp)
Extract pointer to a coupled variable.
Definition: Coupleable.C:117
virtual bool isCoupled(const std::string &var_name, unsigned int i=0)
Returns true if a variables has been coupled as name.
Definition: Coupleable.C:91
unsigned int number() const
Get variable number coming from libMesh.
std::map< std::string, unsigned int > _optional_var_index
Unique indices for optionally coupled vars that weren&#39;t provided.
Definition: Coupleable.h:378
void Coupleable::coupledCallback ( const std::string &  var_name,
bool  is_old 
)
protectedvirtual
unsigned int Coupleable::coupledComponents ( const std::string &  var_name)
protected

Number of coupled components.

Parameters
var_nameName of the variable
Returns
number of components this variable has (usually 1)

Definition at line 111 of file Coupleable.C.

Referenced by NodalEqualValueConstraint::NodalEqualValueConstraint(), SphericalAverage::SphericalAverage(), and VolumeHistogram::VolumeHistogram().

112 {
113  return _coupled_vars[var_name].size();
114 }
std::map< std::string, std::vector< MooseVariable * > > _coupled_vars
Coupled vars whose values we provide.
Definition: Coupleable.h:321
const VariableValue & Coupleable::coupledDot ( const std::string &  var_name,
unsigned int  comp = 0 
)
protectedvirtual

Time derivative of a coupled variable.

Parameters
var_nameName of coupled variable
compComponent number for vector of coupled variables
Returns
Reference to a VariableValue containing the time derivative of the coupled variable
See also
Kernel::dot

Reimplemented in AuxKernel.

Definition at line 296 of file Coupleable.C.

Referenced by AuxKernel::coupledDot().

297 {
298  if (!isCoupled(var_name)) // Return default 0
299  return _default_value_zero;
300 
301  MooseVariable * var = getVar(var_name, comp);
302 
304  {
305  if (_c_nodal)
306  return var->nodalSlnDot();
307  else
308  return var->uDot();
309  }
310  else
311  {
312  if (_c_nodal)
313  return var->nodalSlnDotNeighbor();
314  else
315  return var->uDotNeighbor();
316  }
317 }
bool _c_nodal
True if we provide coupling to nodal values.
Definition: Coupleable.h:327
Class for stuff related to variables.
Definition: MooseVariable.h:43
const VariableValue & uDotNeighbor()
VariableValue _default_value_zero
This will always be zero because the default values for optionally coupled variables is always consta...
Definition: Coupleable.h:339
MooseVariable * getVar(const std::string &var_name, unsigned int comp)
Extract pointer to a coupled variable.
Definition: Coupleable.C:117
const VariableValue & nodalSlnDot()
virtual bool isCoupled(const std::string &var_name, unsigned int i=0)
Returns true if a variables has been coupled as name.
Definition: Coupleable.C:91
bool _coupleable_neighbor
Whether or not this object is a "neighbor" object: ie all of it&#39;s coupled values should be neighbor v...
Definition: Coupleable.h:363
const VariableValue & uDot()
const VariableValue & nodalSlnDotNeighbor()
const VariableValue & Coupleable::coupledDotDu ( const std::string &  var_name,
unsigned int  comp = 0 
)
protectedvirtual

Time derivative of a coupled variable with respect to the coefficients.

Parameters
var_nameName of coupled variable
compComponent number for vector of coupled variables
Returns
Reference to a VariableValue containing the time derivative of the coupled variable with respect to the coefficients
See also
Kernel:dotDu

Reimplemented in AuxKernel.

Definition at line 320 of file Coupleable.C.

Referenced by AuxKernel::coupledDotDu().

321 {
322  if (!isCoupled(var_name)) // Return default 0
323  return _default_value_zero;
324 
325  MooseVariable * var = getVar(var_name, comp);
326 
328  {
329  if (_c_nodal)
330  return var->nodalSlnDuDotDu();
331  else
332  return var->duDotDu();
333  }
334  else
335  {
336  if (_c_nodal)
337  return var->nodalSlnDuDotDu();
338  else
339  return var->duDotDu();
340  }
341 }
bool _c_nodal
True if we provide coupling to nodal values.
Definition: Coupleable.h:327
Class for stuff related to variables.
Definition: MooseVariable.h:43
VariableValue _default_value_zero
This will always be zero because the default values for optionally coupled variables is always consta...
Definition: Coupleable.h:339
MooseVariable * getVar(const std::string &var_name, unsigned int comp)
Extract pointer to a coupled variable.
Definition: Coupleable.C:117
virtual bool isCoupled(const std::string &var_name, unsigned int i=0)
Returns true if a variables has been coupled as name.
Definition: Coupleable.C:91
const VariableValue & duDotDu()
bool _coupleable_neighbor
Whether or not this object is a "neighbor" object: ie all of it&#39;s coupled values should be neighbor v...
Definition: Coupleable.h:363
const VariableValue & nodalSlnDuDotDu()
const VariableGradient & Coupleable::coupledGradient ( const std::string &  var_name,
unsigned int  comp = 0 
)
protectedvirtual

Returns gradient of a coupled variable.

Parameters
var_nameName of coupled variable
compComponent number for vector of coupled variables
Returns
Reference to a VariableGradient containing the gradient of the coupled variable
See also
Kernel::gradient

Definition at line 344 of file Coupleable.C.

345 {
346  if (!isCoupled(var_name)) // Return default 0
347  return _default_gradient;
348 
349  coupledCallback(var_name, false);
350  if (_c_nodal)
351  mooseError("Nodal variables do not have gradients");
352 
353  MooseVariable * var = getVar(var_name, comp);
354 
356  return (_c_is_implicit) ? var->gradSln() : var->gradSlnOld();
357  else
358  return (_c_is_implicit) ? var->gradSlnNeighbor() : var->gradSlnOldNeighbor();
359 }
const VariableGradient & gradSlnNeighbor()
bool _c_nodal
True if we provide coupling to nodal values.
Definition: Coupleable.h:327
const VariableGradient & gradSlnOld()
Class for stuff related to variables.
Definition: MooseVariable.h:43
void mooseError(Args &&...args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:182
const VariableGradient & gradSlnOldNeighbor()
MooseVariable * getVar(const std::string &var_name, unsigned int comp)
Extract pointer to a coupled variable.
Definition: Coupleable.C:117
bool _c_is_implicit
True if implicit value is required.
Definition: Coupleable.h:330
virtual bool isCoupled(const std::string &var_name, unsigned int i=0)
Returns true if a variables has been coupled as name.
Definition: Coupleable.C:91
virtual void coupledCallback(const std::string &var_name, bool is_old)
Definition: Coupleable.C:86
VariableGradient _default_gradient
This will always be zero because the default values for optionally coupled variables is always consta...
Definition: Coupleable.h:342
bool _coupleable_neighbor
Whether or not this object is a "neighbor" object: ie all of it&#39;s coupled values should be neighbor v...
Definition: Coupleable.h:363
const VariableGradient & gradSln()
const VariableGradient & Coupleable::coupledGradientOld ( const std::string &  var_name,
unsigned int  comp = 0 
)
protectedvirtual

Returns an old gradient from previous time step of a coupled variable.

Parameters
var_nameName of coupled variable
compComponent number for vector of coupled variables
Returns
Reference to a VariableGradient containing the old gradient of the coupled variable
See also
Kernel::gradientOld

Definition at line 362 of file Coupleable.C.

363 {
364  if (!isCoupled(var_name)) // Return default 0
365  return _default_gradient;
366 
367  coupledCallback(var_name, true);
368  if (_c_nodal)
369  mooseError("Nodal variables do not have gradients");
370 
371  validateExecutionerType(var_name);
372  MooseVariable * var = getVar(var_name, comp);
373 
375  return (_c_is_implicit) ? var->gradSlnOld() : var->gradSlnOlder();
376  else
377  return (_c_is_implicit) ? var->gradSlnOldNeighbor() : var->gradSlnOlderNeighbor();
378 }
void validateExecutionerType(const std::string &name) const
Checks to make sure that the current Executioner has set "_it_transient" when old/older values are co...
Definition: Coupleable.C:646
bool _c_nodal
True if we provide coupling to nodal values.
Definition: Coupleable.h:327
const VariableGradient & gradSlnOld()
Class for stuff related to variables.
Definition: MooseVariable.h:43
void mooseError(Args &&...args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:182
const VariableGradient & gradSlnOldNeighbor()
MooseVariable * getVar(const std::string &var_name, unsigned int comp)
Extract pointer to a coupled variable.
Definition: Coupleable.C:117
bool _c_is_implicit
True if implicit value is required.
Definition: Coupleable.h:330
virtual bool isCoupled(const std::string &var_name, unsigned int i=0)
Returns true if a variables has been coupled as name.
Definition: Coupleable.C:91
virtual void coupledCallback(const std::string &var_name, bool is_old)
Definition: Coupleable.C:86
VariableGradient _default_gradient
This will always be zero because the default values for optionally coupled variables is always consta...
Definition: Coupleable.h:342
const VariableGradient & gradSlnOlderNeighbor()
bool _coupleable_neighbor
Whether or not this object is a "neighbor" object: ie all of it&#39;s coupled values should be neighbor v...
Definition: Coupleable.h:363
const VariableGradient & gradSlnOlder()
const VariableGradient & Coupleable::coupledGradientOlder ( const std::string &  var_name,
unsigned int  comp = 0 
)
protectedvirtual

Returns an old gradient from two time steps previous of a coupled variable.

Parameters
var_nameName of coupled variable
compComponent number for vector of coupled variables
Returns
Reference to a VariableGradient containing the older gradient of the coupled variable
See also
Kernel::gradientOlder

Definition at line 381 of file Coupleable.C.

382 {
383  if (!isCoupled(var_name)) // Return default 0
384  return _default_gradient;
385 
386  coupledCallback(var_name, true);
387  if (_c_nodal)
388  mooseError("Nodal variables do not have gradients");
389 
390  validateExecutionerType(var_name);
391  MooseVariable * var = getVar(var_name, comp);
392 
393  if (_c_is_implicit)
394  {
396  return var->gradSlnOlder();
397  else
398  return var->gradSlnOlderNeighbor();
399  }
400  else
401  mooseError("Older values not available for explicit schemes");
402 }
void validateExecutionerType(const std::string &name) const
Checks to make sure that the current Executioner has set "_it_transient" when old/older values are co...
Definition: Coupleable.C:646
bool _c_nodal
True if we provide coupling to nodal values.
Definition: Coupleable.h:327
Class for stuff related to variables.
Definition: MooseVariable.h:43
void mooseError(Args &&...args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:182
MooseVariable * getVar(const std::string &var_name, unsigned int comp)
Extract pointer to a coupled variable.
Definition: Coupleable.C:117
bool _c_is_implicit
True if implicit value is required.
Definition: Coupleable.h:330
virtual bool isCoupled(const std::string &var_name, unsigned int i=0)
Returns true if a variables has been coupled as name.
Definition: Coupleable.C:91
virtual void coupledCallback(const std::string &var_name, bool is_old)
Definition: Coupleable.C:86
VariableGradient _default_gradient
This will always be zero because the default values for optionally coupled variables is always consta...
Definition: Coupleable.h:342
const VariableGradient & gradSlnOlderNeighbor()
bool _coupleable_neighbor
Whether or not this object is a "neighbor" object: ie all of it&#39;s coupled values should be neighbor v...
Definition: Coupleable.h:363
const VariableGradient & gradSlnOlder()
const VariableGradient & Coupleable::coupledGradientPreviousNL ( const std::string &  var_name,
unsigned int  comp = 0 
)
protectedvirtual

Returns gradient of a coupled variable for previous Newton iterate.

Parameters
var_nameName of coupled variable
compComponent number for vector of coupled variables
Returns
Reference to a VariableGradient containing the gradient of the coupled variable

Definition at line 405 of file Coupleable.C.

406 {
407  if (!isCoupled(var_name)) // Return default 0
408  return _default_gradient;
409 
411  coupledCallback(var_name, true);
412  if (_c_nodal)
413  mooseError("Nodal variables do not have gradients");
414 
415  MooseVariable * var = getVar(var_name, comp);
416 
418  return var->gradSlnPreviousNL();
419  else
420  return var->gradSlnPreviousNLNeighbor();
421 }
bool _c_nodal
True if we provide coupling to nodal values.
Definition: Coupleable.h:327
Class for stuff related to variables.
Definition: MooseVariable.h:43
void mooseError(Args &&...args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:182
MooseVariable * getVar(const std::string &var_name, unsigned int comp)
Extract pointer to a coupled variable.
Definition: Coupleable.C:117
const VariableGradient & gradSlnPreviousNLNeighbor()
FEProblemBase & _c_fe_problem
Definition: Coupleable.h:318
virtual bool isCoupled(const std::string &var_name, unsigned int i=0)
Returns true if a variables has been coupled as name.
Definition: Coupleable.C:91
virtual void coupledCallback(const std::string &var_name, bool is_old)
Definition: Coupleable.C:86
VariableGradient _default_gradient
This will always be zero because the default values for optionally coupled variables is always consta...
Definition: Coupleable.h:342
const VariableGradient & gradSlnPreviousNL()
void needsPreviousNewtonIteration(bool state)
Set a flag that indicated that user required values for the previous Newton iterate.
bool _coupleable_neighbor
Whether or not this object is a "neighbor" object: ie all of it&#39;s coupled values should be neighbor v...
Definition: Coupleable.h:363
const VariableValue & Coupleable::coupledNodalDot ( const std::string &  var_name,
unsigned int  comp = 0 
)
protectedvirtual

Nodal values of time derivative of a coupled variable.

Parameters
var_nameName of coupled variable
compComponent number for vector of coupled variables
Returns
Reference to a VariableValue containing the nodal values of time derivative of the coupled variable

Definition at line 568 of file Coupleable.C.

569 {
570  if (!isCoupled(var_name)) // Return default 0
571  return _default_value_zero;
572 
573  coupledCallback(var_name, false);
574  MooseVariable * var = getVar(var_name, comp);
575 
577  return var->nodalValueDot();
578  else
579  return var->nodalValueDotNeighbor();
580 }
Class for stuff related to variables.
Definition: MooseVariable.h:43
VariableValue _default_value_zero
This will always be zero because the default values for optionally coupled variables is always consta...
Definition: Coupleable.h:339
MooseVariable * getVar(const std::string &var_name, unsigned int comp)
Extract pointer to a coupled variable.
Definition: Coupleable.C:117
const VariableValue & nodalValueDotNeighbor()
virtual bool isCoupled(const std::string &var_name, unsigned int i=0)
Returns true if a variables has been coupled as name.
Definition: Coupleable.C:91
virtual void coupledCallback(const std::string &var_name, bool is_old)
Definition: Coupleable.C:86
bool _coupleable_neighbor
Whether or not this object is a "neighbor" object: ie all of it&#39;s coupled values should be neighbor v...
Definition: Coupleable.h:363
const VariableValue & nodalValueDot()
const VariableValue & Coupleable::coupledNodalValue ( const std::string &  var_name,
unsigned int  comp = 0 
)
protectedvirtual

Returns nodal values of a coupled variable.

Parameters
var_nameName of coupled variable
compComponent number for vector of coupled variables
Returns
Reference to a VariableValue for the coupled variable

Definition at line 501 of file Coupleable.C.

502 {
503  if (!isCoupled(var_name))
504  return *getDefaultValue(var_name);
505 
506  coupledCallback(var_name, false);
507  MooseVariable * var = getVar(var_name, comp);
508 
510  return (_c_is_implicit) ? var->nodalValue() : var->nodalValueOld();
511  else
512  return (_c_is_implicit) ? var->nodalValueNeighbor() : var->nodalValueOldNeighbor();
513 }
const VariableValue & nodalValue()
Class for stuff related to variables.
Definition: MooseVariable.h:43
const VariableValue & nodalValueNeighbor()
MooseVariable * getVar(const std::string &var_name, unsigned int comp)
Extract pointer to a coupled variable.
Definition: Coupleable.C:117
VariableValue * getDefaultValue(const std::string &var_name)
Helper method to return (and insert if necessary) the default value for an uncoupled variable...
Definition: Coupleable.C:153
bool _c_is_implicit
True if implicit value is required.
Definition: Coupleable.h:330
virtual bool isCoupled(const std::string &var_name, unsigned int i=0)
Returns true if a variables has been coupled as name.
Definition: Coupleable.C:91
virtual void coupledCallback(const std::string &var_name, bool is_old)
Definition: Coupleable.C:86
const VariableValue & nodalValueOldNeighbor()
const VariableValue & nodalValueOld()
bool _coupleable_neighbor
Whether or not this object is a "neighbor" object: ie all of it&#39;s coupled values should be neighbor v...
Definition: Coupleable.h:363
const VariableValue & Coupleable::coupledNodalValueOld ( const std::string &  var_name,
unsigned int  comp = 0 
)
protectedvirtual

Returns an old nodal value from previous time step of a coupled variable.

Parameters
var_nameName of coupled variable
compComponent number for vector of coupled variables
Returns
Reference to a VariableValue containing the old value of the coupled variable

Definition at line 516 of file Coupleable.C.

517 {
518  if (!isCoupled(var_name))
519  return *getDefaultValue(var_name);
520 
521  validateExecutionerType(var_name);
522  coupledCallback(var_name, true);
523  MooseVariable * var = getVar(var_name, comp);
524 
526  return (_c_is_implicit) ? var->nodalValueOld() : var->nodalValueOlder();
527  else
529 }
void validateExecutionerType(const std::string &name) const
Checks to make sure that the current Executioner has set "_it_transient" when old/older values are co...
Definition: Coupleable.C:646
Class for stuff related to variables.
Definition: MooseVariable.h:43
MooseVariable * getVar(const std::string &var_name, unsigned int comp)
Extract pointer to a coupled variable.
Definition: Coupleable.C:117
VariableValue * getDefaultValue(const std::string &var_name)
Helper method to return (and insert if necessary) the default value for an uncoupled variable...
Definition: Coupleable.C:153
bool _c_is_implicit
True if implicit value is required.
Definition: Coupleable.h:330
virtual bool isCoupled(const std::string &var_name, unsigned int i=0)
Returns true if a variables has been coupled as name.
Definition: Coupleable.C:91
virtual void coupledCallback(const std::string &var_name, bool is_old)
Definition: Coupleable.C:86
const VariableValue & nodalValueOldNeighbor()
const VariableValue & nodalValueOld()
bool _coupleable_neighbor
Whether or not this object is a "neighbor" object: ie all of it&#39;s coupled values should be neighbor v...
Definition: Coupleable.h:363
const VariableValue & nodalValueOlderNeighbor()
const VariableValue & nodalValueOlder()
const VariableValue & Coupleable::coupledNodalValueOlder ( const std::string &  var_name,
unsigned int  comp = 0 
)
protectedvirtual

Returns an old nodal value from two time steps previous of a coupled variable.

Parameters
var_nameName of coupled variable
compComponent number for vector of coupled variables
Returns
Reference to a VariableValue containing the older value of the coupled variable

Definition at line 532 of file Coupleable.C.

533 {
534  if (!isCoupled(var_name))
535  return *getDefaultValue(var_name);
536 
537  validateExecutionerType(var_name);
538  coupledCallback(var_name, true);
539  MooseVariable * var = getVar(var_name, comp);
540  if (_c_is_implicit)
541  {
543  return var->nodalValueOlder();
544  else
545  return var->nodalValueOlderNeighbor();
546  }
547  else
548  mooseError("Older values not available for explicit schemes");
549 }
void validateExecutionerType(const std::string &name) const
Checks to make sure that the current Executioner has set "_it_transient" when old/older values are co...
Definition: Coupleable.C:646
Class for stuff related to variables.
Definition: MooseVariable.h:43
void mooseError(Args &&...args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:182
MooseVariable * getVar(const std::string &var_name, unsigned int comp)
Extract pointer to a coupled variable.
Definition: Coupleable.C:117
VariableValue * getDefaultValue(const std::string &var_name)
Helper method to return (and insert if necessary) the default value for an uncoupled variable...
Definition: Coupleable.C:153
bool _c_is_implicit
True if implicit value is required.
Definition: Coupleable.h:330
virtual bool isCoupled(const std::string &var_name, unsigned int i=0)
Returns true if a variables has been coupled as name.
Definition: Coupleable.C:91
virtual void coupledCallback(const std::string &var_name, bool is_old)
Definition: Coupleable.C:86
bool _coupleable_neighbor
Whether or not this object is a "neighbor" object: ie all of it&#39;s coupled values should be neighbor v...
Definition: Coupleable.h:363
const VariableValue & nodalValueOlderNeighbor()
const VariableValue & nodalValueOlder()
const VariableValue & Coupleable::coupledNodalValuePreviousNL ( const std::string &  var_name,
unsigned int  comp = 0 
)
protectedvirtual

Returns nodal values of a coupled variable for previous Newton iterate.

Parameters
var_nameName of coupled variable
compComponent number for vector of coupled variables
Returns
Reference to a VariableValue for the coupled variable

Definition at line 552 of file Coupleable.C.

553 {
554  if (!isCoupled(var_name))
555  return *getDefaultValue(var_name);
556 
558  coupledCallback(var_name, true);
559  MooseVariable * var = getVar(var_name, comp);
560 
562  return var->nodalValuePreviousNL();
563  else
564  return var->nodalValuePreviousNLNeighbor();
565 }
Class for stuff related to variables.
Definition: MooseVariable.h:43
MooseVariable * getVar(const std::string &var_name, unsigned int comp)
Extract pointer to a coupled variable.
Definition: Coupleable.C:117
VariableValue * getDefaultValue(const std::string &var_name)
Helper method to return (and insert if necessary) the default value for an uncoupled variable...
Definition: Coupleable.C:153
const VariableValue & nodalValuePreviousNL()
FEProblemBase & _c_fe_problem
Definition: Coupleable.h:318
virtual bool isCoupled(const std::string &var_name, unsigned int i=0)
Returns true if a variables has been coupled as name.
Definition: Coupleable.C:91
virtual void coupledCallback(const std::string &var_name, bool is_old)
Definition: Coupleable.C:86
void needsPreviousNewtonIteration(bool state)
Set a flag that indicated that user required values for the previous Newton iterate.
bool _coupleable_neighbor
Whether or not this object is a "neighbor" object: ie all of it&#39;s coupled values should be neighbor v...
Definition: Coupleable.h:363
const VariableValue & nodalValuePreviousNLNeighbor()
const VariableSecond & Coupleable::coupledSecond ( const std::string &  var_name,
unsigned int  comp = 0 
)
protectedvirtual

Returns second derivative of a coupled variable.

Parameters
var_nameName of coupled variable
compComponent number for vector of coupled variables
Returns
Reference to a VariableSecond containing the second derivative of the coupled variable
See also
Kernel::second

Definition at line 424 of file Coupleable.C.

425 {
426  if (!isCoupled(var_name)) // Return default 0
427  return _default_second;
428 
429  coupledCallback(var_name, false);
430  if (_c_nodal)
431  mooseError("Nodal variables do not have second derivatives");
432 
433  MooseVariable * var = getVar(var_name, comp);
434 
436  return (_c_is_implicit) ? var->secondSln() : var->secondSlnOlder();
437  else
438  return (_c_is_implicit) ? var->secondSlnNeighbor() : var->secondSlnOlderNeighbor();
439 }
bool _c_nodal
True if we provide coupling to nodal values.
Definition: Coupleable.h:327
Class for stuff related to variables.
Definition: MooseVariable.h:43
void mooseError(Args &&...args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:182
const VariableSecond & secondSln()
MooseVariable * getVar(const std::string &var_name, unsigned int comp)
Extract pointer to a coupled variable.
Definition: Coupleable.C:117
const VariableSecond & secondSlnOlder()
bool _c_is_implicit
True if implicit value is required.
Definition: Coupleable.h:330
virtual bool isCoupled(const std::string &var_name, unsigned int i=0)
Returns true if a variables has been coupled as name.
Definition: Coupleable.C:91
virtual void coupledCallback(const std::string &var_name, bool is_old)
Definition: Coupleable.C:86
VariableSecond _default_second
This will always be zero because the default values for optionally coupled variables is always consta...
Definition: Coupleable.h:345
const VariableSecond & secondSlnOlderNeighbor()
bool _coupleable_neighbor
Whether or not this object is a "neighbor" object: ie all of it&#39;s coupled values should be neighbor v...
Definition: Coupleable.h:363
const VariableSecond & secondSlnNeighbor()
const VariableSecond & Coupleable::coupledSecondOld ( const std::string &  var_name,
unsigned int  comp = 0 
)
protectedvirtual

Returns an old second derivative from previous time step of a coupled variable.

Parameters
var_nameName of coupled variable
compComponent number for vector of coupled variables
Returns
Reference to a VariableSecond containing the old second derivative of the coupled variable
See also
Kernel::secondOld

Definition at line 442 of file Coupleable.C.

443 {
444  if (!isCoupled(var_name)) // Return default 0
445  return _default_second;
446 
447  coupledCallback(var_name, true);
448  if (_c_nodal)
449  mooseError("Nodal variables do not have second derivatives");
450 
451  validateExecutionerType(var_name);
452  MooseVariable * var = getVar(var_name, comp);
454  return (_c_is_implicit) ? var->secondSlnOld() : var->secondSlnOlder();
455  else
457 }
void validateExecutionerType(const std::string &name) const
Checks to make sure that the current Executioner has set "_it_transient" when old/older values are co...
Definition: Coupleable.C:646
const VariableSecond & secondSlnOldNeighbor()
bool _c_nodal
True if we provide coupling to nodal values.
Definition: Coupleable.h:327
Class for stuff related to variables.
Definition: MooseVariable.h:43
void mooseError(Args &&...args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:182
MooseVariable * getVar(const std::string &var_name, unsigned int comp)
Extract pointer to a coupled variable.
Definition: Coupleable.C:117
const VariableSecond & secondSlnOld()
const VariableSecond & secondSlnOlder()
bool _c_is_implicit
True if implicit value is required.
Definition: Coupleable.h:330
virtual bool isCoupled(const std::string &var_name, unsigned int i=0)
Returns true if a variables has been coupled as name.
Definition: Coupleable.C:91
virtual void coupledCallback(const std::string &var_name, bool is_old)
Definition: Coupleable.C:86
VariableSecond _default_second
This will always be zero because the default values for optionally coupled variables is always consta...
Definition: Coupleable.h:345
const VariableSecond & secondSlnOlderNeighbor()
bool _coupleable_neighbor
Whether or not this object is a "neighbor" object: ie all of it&#39;s coupled values should be neighbor v...
Definition: Coupleable.h:363
const VariableSecond & Coupleable::coupledSecondOlder ( const std::string &  var_name,
unsigned int  comp = 0 
)
protectedvirtual

Returns an old second derivative from two time steps previous of a coupled variable.

Parameters
var_nameName of coupled variable
compComponent number for vector of coupled variables
Returns
Reference to a VariableSecond containing the older second derivative of the coupled variable
See also
Kernel::secondOlder

Definition at line 460 of file Coupleable.C.

461 {
462  if (!isCoupled(var_name)) // Return default 0
463  return _default_second;
464 
465  coupledCallback(var_name, true);
466  if (_c_nodal)
467  mooseError("Nodal variables do not have second derivatives");
468 
469  validateExecutionerType(var_name);
470  MooseVariable * var = getVar(var_name, comp);
471  if (_c_is_implicit)
472  {
474  return var->secondSlnOlder();
475  else
476  return var->secondSlnOlderNeighbor();
477  }
478  else
479  mooseError("Older values not available for explicit schemes");
480 }
void validateExecutionerType(const std::string &name) const
Checks to make sure that the current Executioner has set "_it_transient" when old/older values are co...
Definition: Coupleable.C:646
bool _c_nodal
True if we provide coupling to nodal values.
Definition: Coupleable.h:327
Class for stuff related to variables.
Definition: MooseVariable.h:43
void mooseError(Args &&...args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:182
MooseVariable * getVar(const std::string &var_name, unsigned int comp)
Extract pointer to a coupled variable.
Definition: Coupleable.C:117
const VariableSecond & secondSlnOlder()
bool _c_is_implicit
True if implicit value is required.
Definition: Coupleable.h:330
virtual bool isCoupled(const std::string &var_name, unsigned int i=0)
Returns true if a variables has been coupled as name.
Definition: Coupleable.C:91
virtual void coupledCallback(const std::string &var_name, bool is_old)
Definition: Coupleable.C:86
VariableSecond _default_second
This will always be zero because the default values for optionally coupled variables is always consta...
Definition: Coupleable.h:345
const VariableSecond & secondSlnOlderNeighbor()
bool _coupleable_neighbor
Whether or not this object is a "neighbor" object: ie all of it&#39;s coupled values should be neighbor v...
Definition: Coupleable.h:363
const VariableSecond & Coupleable::coupledSecondPreviousNL ( const std::string &  var_name,
unsigned int  comp = 0 
)
protectedvirtual

Returns second derivative of a coupled variable for the previous Newton iterate.

Parameters
var_nameName of coupled variable
compComponent number for vector of coupled variables
Returns
Reference to a VariableSecond containing the second derivative of the coupled variable

Definition at line 483 of file Coupleable.C.

484 {
485  if (!isCoupled(var_name)) // Return default 0
486  return _default_second;
487 
489  coupledCallback(var_name, true);
490  if (_c_nodal)
491  mooseError("Nodal variables do not have second derivatives");
492 
493  MooseVariable * var = getVar(var_name, comp);
495  return var->secondSlnPreviousNL();
496  else
497  return var->secondSlnPreviousNLNeighbor();
498 }
bool _c_nodal
True if we provide coupling to nodal values.
Definition: Coupleable.h:327
const VariableSecond & secondSlnPreviousNL()
Class for stuff related to variables.
Definition: MooseVariable.h:43
void mooseError(Args &&...args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:182
MooseVariable * getVar(const std::string &var_name, unsigned int comp)
Extract pointer to a coupled variable.
Definition: Coupleable.C:117
FEProblemBase & _c_fe_problem
Definition: Coupleable.h:318
virtual bool isCoupled(const std::string &var_name, unsigned int i=0)
Returns true if a variables has been coupled as name.
Definition: Coupleable.C:91
virtual void coupledCallback(const std::string &var_name, bool is_old)
Definition: Coupleable.C:86
VariableSecond _default_second
This will always be zero because the default values for optionally coupled variables is always consta...
Definition: Coupleable.h:345
void needsPreviousNewtonIteration(bool state)
Set a flag that indicated that user required values for the previous Newton iterate.
bool _coupleable_neighbor
Whether or not this object is a "neighbor" object: ie all of it&#39;s coupled values should be neighbor v...
Definition: Coupleable.h:363
const VariableSecond & secondSlnPreviousNLNeighbor()
const DenseVector< Number > & Coupleable::coupledSolutionDoFs ( const std::string &  var_name,
unsigned int  comp = 0 
)
protectedvirtual

Returns DoFs in the current solution vector of a coupled variable for the local element.

Parameters
var_nameName of coupled variable
compComponent number for vector of coupled variables
Returns
Reference to a DenseVector for the DoFs of the coupled variable

Definition at line 583 of file Coupleable.C.

584 {
585  // default coupling is not available for elemental solutions
586  if (!isCoupled(var_name))
587  mooseError("invalid variable name for coupledSolutionDoFs");
588 
589  if (_c_nodal)
590  mooseError("nodal objects should not call coupledSolutionDoFs");
591 
592  coupledCallback(var_name, false);
593  MooseVariable * var = getVar(var_name, comp);
594 
596  return (_c_is_implicit) ? var->solutionDoFs() : var->solutionDoFsOld();
597  else
599 }
bool _c_nodal
True if we provide coupling to nodal values.
Definition: Coupleable.h:327
const DenseVector< Number > & solutionDoFsOld()
Class for stuff related to variables.
Definition: MooseVariable.h:43
const DenseVector< Number > & solutionDoFsNeighbor()
void mooseError(Args &&...args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:182
MooseVariable * getVar(const std::string &var_name, unsigned int comp)
Extract pointer to a coupled variable.
Definition: Coupleable.C:117
const DenseVector< Number > & solutionDoFs()
bool _c_is_implicit
True if implicit value is required.
Definition: Coupleable.h:330
virtual bool isCoupled(const std::string &var_name, unsigned int i=0)
Returns true if a variables has been coupled as name.
Definition: Coupleable.C:91
virtual void coupledCallback(const std::string &var_name, bool is_old)
Definition: Coupleable.C:86
bool _coupleable_neighbor
Whether or not this object is a "neighbor" object: ie all of it&#39;s coupled values should be neighbor v...
Definition: Coupleable.h:363
const DenseVector< Number > & solutionDoFsOldNeighbor()
const DenseVector< Number > & Coupleable::coupledSolutionDoFsOld ( const std::string &  var_name,
unsigned int  comp = 0 
)
protectedvirtual

Returns DoFs in the old solution vector of a coupled variable for the local element.

Parameters
var_nameName of coupled variable
compComponent number for vector of coupled variables
Returns
Reference to a DenseVector for the old DoFs of the coupled variable

Definition at line 602 of file Coupleable.C.

603 {
604  // default coupling is not available for elemental solutions
605  if (!isCoupled(var_name))
606  mooseError("invalid variable name for coupledSolutionDoFsOld");
607 
608  if (_c_nodal)
609  mooseError("nodal objects should not call coupledSolutionDoFsOld");
610 
611  validateExecutionerType(var_name);
612  coupledCallback(var_name, true);
613  MooseVariable * var = getVar(var_name, comp);
614 
616  return (_c_is_implicit) ? var->solutionDoFsOld() : var->solutionDoFsOlder();
617  else
619 }
void validateExecutionerType(const std::string &name) const
Checks to make sure that the current Executioner has set "_it_transient" when old/older values are co...
Definition: Coupleable.C:646
bool _c_nodal
True if we provide coupling to nodal values.
Definition: Coupleable.h:327
const DenseVector< Number > & solutionDoFsOld()
Class for stuff related to variables.
Definition: MooseVariable.h:43
void mooseError(Args &&...args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:182
MooseVariable * getVar(const std::string &var_name, unsigned int comp)
Extract pointer to a coupled variable.
Definition: Coupleable.C:117
bool _c_is_implicit
True if implicit value is required.
Definition: Coupleable.h:330
virtual bool isCoupled(const std::string &var_name, unsigned int i=0)
Returns true if a variables has been coupled as name.
Definition: Coupleable.C:91
const DenseVector< Number > & solutionDoFsOlder()
virtual void coupledCallback(const std::string &var_name, bool is_old)
Definition: Coupleable.C:86
bool _coupleable_neighbor
Whether or not this object is a "neighbor" object: ie all of it&#39;s coupled values should be neighbor v...
Definition: Coupleable.h:363
const DenseVector< Number > & solutionDoFsOlderNeighbor()
const DenseVector< Number > & solutionDoFsOldNeighbor()
const DenseVector< Number > & Coupleable::coupledSolutionDoFsOlder ( const std::string &  var_name,
unsigned int  comp = 0 
)
protectedvirtual

Returns DoFs in the older solution vector of a coupled variable for the local element.

Parameters
var_nameName of coupled variable
compComponent number for vector of coupled variables
Returns
Reference to a DenseVector for the older DoFs of the coupled variable

Definition at line 622 of file Coupleable.C.

623 {
624  // default coupling is not available for elemental solutions
625  if (!isCoupled(var_name))
626  mooseError("invalid variable name for coupledSolutionDoFsOlder");
627 
628  if (_c_nodal)
629  mooseError("nodal objects should not call coupledSolutionDoFsOlder");
630 
631  validateExecutionerType(var_name);
632  coupledCallback(var_name, true);
633  MooseVariable * var = getVar(var_name, comp);
634  if (_c_is_implicit)
635  {
637  return var->solutionDoFsOlder();
638  else
639  return var->solutionDoFsOlderNeighbor();
640  }
641  else
642  mooseError("Older values not available for explicit schemes");
643 }
void validateExecutionerType(const std::string &name) const
Checks to make sure that the current Executioner has set "_it_transient" when old/older values are co...
Definition: Coupleable.C:646
bool _c_nodal
True if we provide coupling to nodal values.
Definition: Coupleable.h:327
Class for stuff related to variables.
Definition: MooseVariable.h:43
void mooseError(Args &&...args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:182
MooseVariable * getVar(const std::string &var_name, unsigned int comp)
Extract pointer to a coupled variable.
Definition: Coupleable.C:117
bool _c_is_implicit
True if implicit value is required.
Definition: Coupleable.h:330
virtual bool isCoupled(const std::string &var_name, unsigned int i=0)
Returns true if a variables has been coupled as name.
Definition: Coupleable.C:91
const DenseVector< Number > & solutionDoFsOlder()
virtual void coupledCallback(const std::string &var_name, bool is_old)
Definition: Coupleable.C:86
bool _coupleable_neighbor
Whether or not this object is a "neighbor" object: ie all of it&#39;s coupled values should be neighbor v...
Definition: Coupleable.h:363
const DenseVector< Number > & solutionDoFsOlderNeighbor()
const VariableValue & Coupleable::coupledValue ( const std::string &  var_name,
unsigned int  comp = 0 
)
protectedvirtual

Returns value of a coupled variable.

Parameters
var_nameName of coupled variable
compComponent number for vector of coupled variables
Returns
Reference to a VariableValue for the coupled variable
See also
Kernel::value

Definition at line 167 of file Coupleable.C.

Referenced by NodalEqualValueConstraint::NodalEqualValueConstraint(), ParsedAux::ParsedAux(), SphericalAverage::SphericalAverage(), VariableTimeIntegrationAux::VariableTimeIntegrationAux(), and writableCoupledValue().

168 {
169  if (!isCoupled(var_name))
170  return *getDefaultValue(var_name);
171 
172  coupledCallback(var_name, false);
173  MooseVariable * var = getVar(var_name, comp);
174 
176  {
177  if (_c_nodal)
178  return (_c_is_implicit) ? var->nodalSln() : var->nodalSlnOld();
179  else
180  return (_c_is_implicit) ? var->sln() : var->slnOld();
181  }
182  else
183  {
184  if (_c_nodal)
185  return (_c_is_implicit) ? var->nodalSlnNeighbor() : var->nodalSlnOldNeighbor();
186  else
187  return (_c_is_implicit) ? var->slnNeighbor() : var->slnOldNeighbor();
188  }
189 }
bool _c_nodal
True if we provide coupling to nodal values.
Definition: Coupleable.h:327
Class for stuff related to variables.
Definition: MooseVariable.h:43
const VariableValue & nodalSlnNeighbor()
MooseVariable * getVar(const std::string &var_name, unsigned int comp)
Extract pointer to a coupled variable.
Definition: Coupleable.C:117
VariableValue * getDefaultValue(const std::string &var_name)
Helper method to return (and insert if necessary) the default value for an uncoupled variable...
Definition: Coupleable.C:153
bool _c_is_implicit
True if implicit value is required.
Definition: Coupleable.h:330
virtual bool isCoupled(const std::string &var_name, unsigned int i=0)
Returns true if a variables has been coupled as name.
Definition: Coupleable.C:91
const VariableValue & nodalSlnOldNeighbor()
virtual void coupledCallback(const std::string &var_name, bool is_old)
Definition: Coupleable.C:86
const VariableValue & slnOld()
const VariableValue & nodalSlnOld()
const VariableValue & slnOldNeighbor()
bool _coupleable_neighbor
Whether or not this object is a "neighbor" object: ie all of it&#39;s coupled values should be neighbor v...
Definition: Coupleable.h:363
const VariableValue & nodalSln()
const VariableValue & sln()
const VariableValue & slnNeighbor()
const VariableValue & Coupleable::coupledValueOld ( const std::string &  var_name,
unsigned int  comp = 0 
)
protectedvirtual

Returns an old value from previous time step of a coupled variable.

Parameters
var_nameName of coupled variable
compComponent number for vector of coupled variables
Returns
Reference to a VariableValue containing the old value of the coupled variable
See also
Kernel::valueOld

Definition at line 198 of file Coupleable.C.

Referenced by VariableTimeIntegrationAux::VariableTimeIntegrationAux().

199 {
200  if (!isCoupled(var_name))
201  return *getDefaultValue(var_name);
202 
203  validateExecutionerType(var_name);
204  coupledCallback(var_name, true);
205  MooseVariable * var = getVar(var_name, comp);
206 
208  {
209  if (_c_nodal)
210  return (_c_is_implicit) ? var->nodalSlnOld() : var->nodalSlnOlder();
211  else
212  return (_c_is_implicit) ? var->slnOld() : var->slnOlder();
213  }
214  else
215  {
216  if (_c_nodal)
217  return (_c_is_implicit) ? var->nodalSlnOldNeighbor() : var->nodalSlnOlderNeighbor();
218  else
219  return (_c_is_implicit) ? var->slnOldNeighbor() : var->slnOlderNeighbor();
220  }
221 }
void validateExecutionerType(const std::string &name) const
Checks to make sure that the current Executioner has set "_it_transient" when old/older values are co...
Definition: Coupleable.C:646
bool _c_nodal
True if we provide coupling to nodal values.
Definition: Coupleable.h:327
Class for stuff related to variables.
Definition: MooseVariable.h:43
const VariableValue & slnOlder()
MooseVariable * getVar(const std::string &var_name, unsigned int comp)
Extract pointer to a coupled variable.
Definition: Coupleable.C:117
VariableValue * getDefaultValue(const std::string &var_name)
Helper method to return (and insert if necessary) the default value for an uncoupled variable...
Definition: Coupleable.C:153
bool _c_is_implicit
True if implicit value is required.
Definition: Coupleable.h:330
virtual bool isCoupled(const std::string &var_name, unsigned int i=0)
Returns true if a variables has been coupled as name.
Definition: Coupleable.C:91
const VariableValue & nodalSlnOldNeighbor()
virtual void coupledCallback(const std::string &var_name, bool is_old)
Definition: Coupleable.C:86
const VariableValue & slnOld()
const VariableValue & nodalSlnOlderNeighbor()
const VariableValue & nodalSlnOld()
const VariableValue & slnOlderNeighbor()
const VariableValue & nodalSlnOlder()
const VariableValue & slnOldNeighbor()
bool _coupleable_neighbor
Whether or not this object is a "neighbor" object: ie all of it&#39;s coupled values should be neighbor v...
Definition: Coupleable.h:363
const VariableValue & Coupleable::coupledValueOlder ( const std::string &  var_name,
unsigned int  comp = 0 
)
protectedvirtual

Returns an old value from two time steps previous of a coupled variable.

Parameters
var_nameName of coupled variable
compComponent number for vector of coupled variables
Returns
Reference to a VariableValue containing the older value of the coupled variable
See also
Kernel::valueOlder

Definition at line 224 of file Coupleable.C.

Referenced by VariableTimeIntegrationAux::VariableTimeIntegrationAux().

225 {
226  if (!isCoupled(var_name))
227  return *getDefaultValue(var_name);
228 
229  validateExecutionerType(var_name);
230  coupledCallback(var_name, true);
231  MooseVariable * var = getVar(var_name, comp);
232 
234  {
235  if (_c_nodal)
236  {
237  if (_c_is_implicit)
238  return var->nodalSlnOlder();
239  else
240  mooseError("Older values not available for explicit schemes");
241  }
242  else
243  {
244  if (_c_is_implicit)
245  return var->slnOlder();
246  else
247  mooseError("Older values not available for explicit schemes");
248  }
249  }
250  else
251  {
252  if (_c_nodal)
253  {
254  if (_c_is_implicit)
255  return var->nodalSlnOlderNeighbor();
256  else
257  mooseError("Older values not available for explicit schemes");
258  }
259  else
260  {
261  if (_c_is_implicit)
262  return var->slnOlderNeighbor();
263  else
264  mooseError("Older values not available for explicit schemes");
265  }
266  }
267 }
void validateExecutionerType(const std::string &name) const
Checks to make sure that the current Executioner has set "_it_transient" when old/older values are co...
Definition: Coupleable.C:646
bool _c_nodal
True if we provide coupling to nodal values.
Definition: Coupleable.h:327
Class for stuff related to variables.
Definition: MooseVariable.h:43
const VariableValue & slnOlder()
void mooseError(Args &&...args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:182
MooseVariable * getVar(const std::string &var_name, unsigned int comp)
Extract pointer to a coupled variable.
Definition: Coupleable.C:117
VariableValue * getDefaultValue(const std::string &var_name)
Helper method to return (and insert if necessary) the default value for an uncoupled variable...
Definition: Coupleable.C:153
bool _c_is_implicit
True if implicit value is required.
Definition: Coupleable.h:330
virtual bool isCoupled(const std::string &var_name, unsigned int i=0)
Returns true if a variables has been coupled as name.
Definition: Coupleable.C:91
virtual void coupledCallback(const std::string &var_name, bool is_old)
Definition: Coupleable.C:86
const VariableValue & nodalSlnOlderNeighbor()
const VariableValue & slnOlderNeighbor()
const VariableValue & nodalSlnOlder()
bool _coupleable_neighbor
Whether or not this object is a "neighbor" object: ie all of it&#39;s coupled values should be neighbor v...
Definition: Coupleable.h:363
const VariableValue & Coupleable::coupledValuePreviousNL ( const std::string &  var_name,
unsigned int  comp = 0 
)
protectedvirtual

Returns value of previous Newton iterate of a coupled variable.

Parameters
var_nameName of coupled variable
compComponent number for vector of coupled variables
Returns
Reference to a VariableValue containing the older value of the coupled variable

Definition at line 270 of file Coupleable.C.

271 {
272  if (!isCoupled(var_name))
273  return *getDefaultValue(var_name);
274 
276  coupledCallback(var_name, true);
277  MooseVariable * var = getVar(var_name, comp);
278 
280  {
281  if (_c_nodal)
282  return var->nodalSlnPreviousNL();
283  else
284  return var->slnPreviousNL();
285  }
286  else
287  {
288  if (_c_nodal)
289  return var->nodalSlnPreviousNLNeighbor();
290  else
291  return var->slnPreviousNLNeighbor();
292  }
293 }
bool _c_nodal
True if we provide coupling to nodal values.
Definition: Coupleable.h:327
Class for stuff related to variables.
Definition: MooseVariable.h:43
const VariableValue & nodalSlnPreviousNL()
const VariableValue & slnPreviousNLNeighbor()
MooseVariable * getVar(const std::string &var_name, unsigned int comp)
Extract pointer to a coupled variable.
Definition: Coupleable.C:117
VariableValue * getDefaultValue(const std::string &var_name)
Helper method to return (and insert if necessary) the default value for an uncoupled variable...
Definition: Coupleable.C:153
FEProblemBase & _c_fe_problem
Definition: Coupleable.h:318
virtual bool isCoupled(const std::string &var_name, unsigned int i=0)
Returns true if a variables has been coupled as name.
Definition: Coupleable.C:91
virtual void coupledCallback(const std::string &var_name, bool is_old)
Definition: Coupleable.C:86
const VariableValue & nodalSlnPreviousNLNeighbor()
void needsPreviousNewtonIteration(bool state)
Set a flag that indicated that user required values for the previous Newton iterate.
bool _coupleable_neighbor
Whether or not this object is a "neighbor" object: ie all of it&#39;s coupled values should be neighbor v...
Definition: Coupleable.h:363
const VariableValue & slnPreviousNL()
const std::vector<MooseVariable *>& Coupleable::getCoupledMooseVars ( ) const
inline
const std::map<std::string, std::vector<MooseVariable *> >& Coupleable::getCoupledVars ( )
inline

Get the list of coupled variables.

Returns
The list of coupled variables

Definition at line 54 of file Coupleable.h.

Referenced by AuxKernel::AuxKernel(), and InitialCondition::InitialCondition().

55  {
56  return _coupled_vars;
57  }
std::map< std::string, std::vector< MooseVariable * > > _coupled_vars
Coupled vars whose values we provide.
Definition: Coupleable.h:321
VariableValue * Coupleable::getDefaultValue ( const std::string &  var_name)
private

Helper method to return (and insert if necessary) the default value for an uncoupled variable.

Parameters
var_namethe name of the variable for which to retrieve a default value
Returns
VariableValue * a pointer to the associated VarirableValue.

Definition at line 153 of file Coupleable.C.

Referenced by coupledNodalValue(), coupledNodalValueOld(), coupledNodalValueOlder(), coupledNodalValuePreviousNL(), coupledValue(), coupledValueOld(), coupledValueOlder(), and coupledValuePreviousNL().

154 {
155  std::map<std::string, VariableValue *>::iterator default_value_it = _default_value.find(var_name);
156  if (default_value_it == _default_value.end())
157  {
158  VariableValue * value =
160  default_value_it = _default_value.insert(std::make_pair(var_name, value)).first;
161  }
162 
163  return default_value_it->second;
164 }
MooseArray< Real > VariableValue
const InputParameters & _coupleable_params
Local InputParameters.
Definition: Coupleable.h:333
Real defaultCoupledValue(const std::string &coupling_name) const
Get the default value for an optionally coupled variable.
std::map< std::string, VariableValue * > _default_value
Will hold the default value for optional coupled variables.
Definition: Coupleable.h:336
unsigned int _coupleable_max_qps
Maximum qps for any element in this system.
Definition: Coupleable.h:375
MooseVariable * Coupleable::getVar ( const std::string &  var_name,
unsigned int  comp 
)
protected

Extract pointer to a coupled variable.

Parameters
var_nameName of parameter desired
compComponent number of multiple coupled variables
Returns
Pointer to the desired variable

Definition at line 117 of file Coupleable.C.

Referenced by ShapeUserObject< T >::coupled(), coupled(), AuxKernel::coupledDot(), coupledDot(), AuxKernel::coupledDotDu(), coupledDotDu(), coupledGradient(), coupledGradientOld(), coupledGradientOlder(), coupledGradientPreviousNL(), NeighborCoupleable::coupledNeighborGradient(), NeighborCoupleable::coupledNeighborGradientOld(), NeighborCoupleable::coupledNeighborGradientOlder(), NeighborCoupleable::coupledNeighborSecond(), NeighborCoupleable::coupledNeighborSolutionDoFs(), NeighborCoupleable::coupledNeighborSolutionDoFsOld(), NeighborCoupleable::coupledNeighborSolutionDoFsOlder(), NeighborCoupleable::coupledNeighborValue(), NeighborCoupleable::coupledNeighborValueOld(), NeighborCoupleable::coupledNeighborValueOlder(), coupledNodalDot(), coupledNodalValue(), coupledNodalValueOld(), coupledNodalValueOlder(), coupledNodalValuePreviousNL(), coupledSecond(), coupledSecondOld(), coupledSecondOlder(), coupledSecondPreviousNL(), coupledSolutionDoFs(), coupledSolutionDoFsOld(), coupledSolutionDoFsOlder(), coupledValue(), coupledValueOld(), coupledValueOlder(), coupledValuePreviousNL(), ParsedAux::ParsedAux(), PiecewiseLinearInterpolationMaterial::PiecewiseLinearInterpolationMaterial(), and SphericalAverage::SphericalAverage().

118 {
119  if (_coupled_vars.find(var_name) != _coupled_vars.end())
120  {
121  if (comp < _coupled_vars[var_name].size())
122  {
123  // Error check - don't couple elemental to nodal
124  if (!(_coupled_vars[var_name][comp])->isNodal() && _c_nodal)
125  mooseError("You cannot couple an elemental variable to a nodal variable");
126  return _coupled_vars[var_name][comp];
127  }
128  else
129  mooseError("Trying to get a non-existent component of variable '" + var_name + "'");
130  }
131  else
132  mooseError("Trying to get a non-existent variable '" + var_name + "'");
133 }
bool _c_nodal
True if we provide coupling to nodal values.
Definition: Coupleable.h:327
void mooseError(Args &&...args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:182
std::map< std::string, std::vector< MooseVariable * > > _coupled_vars
Coupled vars whose values we provide.
Definition: Coupleable.h:321
bool Coupleable::isCoupled ( const std::string &  var_name,
unsigned int  i = 0 
)
protectedvirtual

Returns true if a variables has been coupled as name.

Parameters
var_nameThe name the kernel wants to refer to the variable as.
iBy default 0, in general the index to test in a vector of MooseVariable pointers.
Returns
True if a coupled variable has the supplied name

Definition at line 91 of file Coupleable.C.

Referenced by coupled(), coupledDot(), coupledDotDu(), coupledGradient(), coupledGradientOld(), coupledGradientOlder(), coupledGradientPreviousNL(), coupledNodalDot(), coupledNodalValue(), coupledNodalValueOld(), coupledNodalValueOlder(), coupledNodalValuePreviousNL(), coupledSecond(), coupledSecondOld(), coupledSecondOlder(), coupledSecondPreviousNL(), coupledSolutionDoFs(), coupledSolutionDoFsOld(), coupledSolutionDoFsOlder(), coupledValue(), coupledValueOld(), coupledValueOlder(), and coupledValuePreviousNL().

92 {
93  std::map<std::string, std::vector<MooseVariable *>>::iterator it = _coupled_vars.find(var_name);
94  if (it != _coupled_vars.end())
95  return (i < it->second.size());
96  else
97  {
98  // Make sure the user originally requested this value in the InputParameter syntax
99  if (!_coupleable_params.hasCoupledValue(var_name))
100  mooseError("The coupled variable \"",
101  var_name,
102  "\" was never added to this objects's "
103  "InputParameters, please double-check your "
104  "spelling");
105 
106  return false;
107  }
108 }
bool hasCoupledValue(const std::string &coupling_name) const
Return whether or not the coupled variable exists.
void mooseError(Args &&...args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:182
std::map< std::string, std::vector< MooseVariable * > > _coupled_vars
Coupled vars whose values we provide.
Definition: Coupleable.h:321
const InputParameters & _coupleable_params
Local InputParameters.
Definition: Coupleable.h:333
void Coupleable::validateExecutionerType ( const std::string &  name) const
protected

Checks to make sure that the current Executioner has set "_it_transient" when old/older values are coupled in.

Parameters
namethe name of the variable

Definition at line 646 of file Coupleable.C.

Referenced by coupledGradientOld(), coupledGradientOlder(), NeighborCoupleable::coupledNeighborGradientOld(), NeighborCoupleable::coupledNeighborGradientOlder(), NeighborCoupleable::coupledNeighborValueOld(), NeighborCoupleable::coupledNeighborValueOlder(), coupledNodalValueOld(), coupledNodalValueOlder(), coupledSecondOld(), coupledSecondOlder(), coupledSolutionDoFsOld(), coupledSolutionDoFsOlder(), coupledValueOld(), and coupledValueOlder().

647 {
648  if (!_c_fe_problem.isTransient())
649  mooseError("You may not couple in old or older values of \"",
650  name,
651  "\" when using a \"Steady\" executioner.");
652 }
void mooseError(Args &&...args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:182
FEProblemBase & _c_fe_problem
Definition: Coupleable.h:318
virtual bool isTransient() const override
VariableValue & Coupleable::writableCoupledValue ( const std::string &  var_name,
unsigned int  comp = 0 
)
protectedvirtual

Returns a writable reference to a coupled variable.

Note: you should not have to use this very often (use coupledValue() instead) but there are situations, such as writing to multiple AuxVariables from a single AuxKernel, where it is required.

Parameters
var_nameName of coupled variable
compComponent number for vector of coupled variables
Returns
Reference to a VariableValue for the coupled variable
See also
Kernel::value

Definition at line 192 of file Coupleable.C.

193 {
194  return const_cast<VariableValue &>(coupledValue(var_name, comp));
195 }
virtual const VariableValue & coupledValue(const std::string &var_name, unsigned int comp=0)
Returns value of a coupled variable.
Definition: Coupleable.C:167

Member Data Documentation

FEProblemBase& Coupleable::_c_fe_problem
protected
bool Coupleable::_c_is_implicit
protected
bool Coupleable::_c_nodal
protected
const InputParameters& Coupleable::_c_parameters
protected

Definition at line 315 of file Coupleable.h.

Referenced by Coupleable().

unsigned int Coupleable::_coupleable_max_qps
private

Maximum qps for any element in this system.

Definition at line 375 of file Coupleable.h.

Referenced by Coupleable(), and getDefaultValue().

bool Coupleable::_coupleable_neighbor
protected
const InputParameters& Coupleable::_coupleable_params
protected

Local InputParameters.

Definition at line 333 of file Coupleable.h.

Referenced by getDefaultValue(), and isCoupled().

std::vector<MooseVariable *> Coupleable::_coupled_moose_vars
protected
std::map<std::string, std::vector<MooseVariable *> > Coupleable::_coupled_vars
protected

Coupled vars whose values we provide.

Definition at line 321 of file Coupleable.h.

Referenced by Coupleable(), coupledComponents(), getVar(), and isCoupled().

VariableGradient Coupleable::_default_gradient
protected

This will always be zero because the default values for optionally coupled variables is always constant.

Definition at line 342 of file Coupleable.h.

Referenced by Coupleable(), coupledGradient(), coupledGradientOld(), coupledGradientOlder(), coupledGradientPreviousNL(), and ~Coupleable().

VariableSecond Coupleable::_default_second
protected

This will always be zero because the default values for optionally coupled variables is always constant.

Definition at line 345 of file Coupleable.h.

Referenced by Coupleable(), coupledSecond(), coupledSecondOld(), coupledSecondOlder(), coupledSecondPreviousNL(), and ~Coupleable().

std::map<std::string, VariableValue *> Coupleable::_default_value
protected

Will hold the default value for optional coupled variables.

Definition at line 336 of file Coupleable.h.

Referenced by getDefaultValue(), and ~Coupleable().

VariableValue Coupleable::_default_value_zero
protected

This will always be zero because the default values for optionally coupled variables is always constant and this is used for time derivative info.

Definition at line 339 of file Coupleable.h.

Referenced by Coupleable(), coupledDot(), coupledDotDu(), coupledNodalDot(), and ~Coupleable().

std::map<std::string, unsigned int> Coupleable::_optional_var_index
private

Unique indices for optionally coupled vars that weren't provided.

Definition at line 378 of file Coupleable.h.

Referenced by Coupleable(), and coupled().


The documentation for this class was generated from the following files: