ScalarCoupleable Class Reference

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

#include <ScalarCoupleable.h>

Inheritance diagram for ScalarCoupleable:

Public Member Functions
	ScalarCoupleable (const MooseObject *moose_object)
	Constructing the object.
	ScalarCoupleable (const ScalarCoupleable &object, const Moose::Kokkos::FunctorCopy &key)
	Special constructor used for Kokkos functor copy during parallel dispatch.
const std::vector< MooseVariableScalar * > &	getCoupledMooseScalarVars ()
	Get the list of coupled scalar variables.
const std::set< TagID > &	getScalarVariableCoupleableVectorTags () const
const std::set< TagID > &	getScalarVariableCoupleableMatrixTags () const

Protected Member Functions
bool	isCoupledScalar (const std::string &var_name, unsigned int i=0) const
	Returns true if a variables has been coupled_as name.
unsigned int	coupledScalarComponents (const std::string &var_name) const
	Return the number of components to the coupled scalar variable.
unsigned int	coupledScalar (const std::string &var_name, unsigned int comp=0) const
	Returns the index for a scalar coupled variable by name.
libMesh::Order	coupledScalarOrder (const std::string &var_name, unsigned int comp=0) const
	Returns the order for a scalar coupled variable by name.
const VariableValue &	coupledScalarValue (const std::string &var_name, unsigned int comp=0) const
	Returns value of a scalar coupled variable.
const ADVariableValue &	adCoupledScalarValue (const std::string &var_name, unsigned int comp=0) const
	Returns AD value of a scalar coupled variable.
template<bool is_ad>
const GenericVariableValue< is_ad > &	coupledGenericScalarValue (const std::string &var_name, unsigned int comp=0) const
	Returns value of a coupled scalar variable for use in templated automatic differentiation classes.
const VariableValue &	coupledVectorTagScalarValue (const std::string &var_name, TagID tag, unsigned int comp=0) const
	Returns value of a scalar coupled variable.
const VariableValue &	coupledMatrixTagScalarValue (const std::string &var_name, TagID tag, unsigned int comp=0) const
	Returns value of a scalar coupled variable.
const VariableValue &	coupledScalarValueOld (const std::string &var_name, unsigned int comp=0) const
	Returns the old (previous time step) value of a scalar coupled variable.
const VariableValue &	coupledScalarValueOlder (const std::string &var_name, unsigned int comp=0) const
	Returns the older (two time steps previous) value of a scalar coupled variable.
const VariableValue &	coupledScalarDot (const std::string &var_name, unsigned int comp=0) const
	Returns the time derivative of a scalar coupled variable.
const ADVariableValue &	adCoupledScalarDot (const std::string &var_name, unsigned int comp=0) const
	Returns the time derivative of a scalar coupled variable, including its dependence on the nonlinear degrees of freedom through automatic differentiation.
const VariableValue &	coupledScalarDotDot (const std::string &var_name, unsigned int comp=0) const
	Returns the second time derivative of a scalar coupled variable.
const VariableValue &	coupledScalarDotOld (const std::string &var_name, unsigned int comp=0) const
	Returns the old time derivative of a scalar coupled variable.
const VariableValue &	coupledScalarDotDotOld (const std::string &var_name, unsigned int comp=0) const
	Returns the old second time derivative of a scalar coupled variable.
const VariableValue &	coupledScalarDotDu (const std::string &var_name, unsigned int comp=0) const
	Time derivative of a scalar coupled variable with respect to the coefficients.
const VariableValue &	coupledScalarDotDotDu (const std::string &var_name, unsigned int comp=0) const
	Second time derivative of a scalar coupled variable with respect to the coefficients.
const MooseVariableScalar *	getScalarVar (const std::string &var_name, unsigned int comp) const
	Extract pointer to a scalar coupled variable.
template<>
const GenericVariableValue< false > &	coupledGenericScalarValue (const std::string &var_name, const unsigned int comp) const
template<>
const GenericVariableValue< true > &	coupledGenericScalarValue (const std::string &var_name, const unsigned int comp) const

Protected Attributes
FEProblemBase &	_sc_fe_problem
const THREAD_ID	_sc_tid
	Thread ID of the thread using this object.
const Real &	_real_zero
	Scalar zero.
const VariableValue &	_scalar_zero
	Zero value of a scalar variable.
const Point &	_point_zero
	Zero point.

Private Member Functions
const VariableValue *	getDefaultValue (const std::string &var_name) const
	Helper method to return (and insert if necessary) the default value for an uncoupled variable.
const ADVariableValue *	getADDefaultValue (const std::string &var_name) const
	Helper method to return (and insert if necessary) the AD default value for an uncoupled variable.
void	checkVar (const std::string &var_name) const
	Check that the right kind of variable is being coupled in.
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 coupled in.

Private Attributes
const InputParameters &	_sc_parameters
const std::string &	_sc_name
	The name of the object this interface is part of.
const bool	_sc_is_implicit
	True if implicit value is required.
std::unordered_map< std::string, std::vector< MooseVariableScalar * > >	_coupled_scalar_vars
	Coupled vars whose values we provide.
std::unordered_map< std::string, std::unique_ptr< VariableValue > >	_default_value
	Will hold the default value for optional coupled scalar variables.
std::unordered_map< std::string, std::unique_ptr< ADVariableValue > >	_dual_default_value
	Will hold the default AD value for optional coupled scalar variables.
std::vector< MooseVariableScalar * >	_coupled_moose_scalar_vars
	Vector of coupled variables.
std::unordered_map< std::string, std::vector< MooseVariableFieldBase * > >	_sc_coupled_vars
	Field variables coupled into this object (for error checking)
std::set< TagID >	_sc_coupleable_vector_tags
	The scalar coupleable vector tags.
std::set< TagID >	_sc_coupleable_matrix_tags
	The scalar coupleable matrix tags.

Detailed Description

Interface for objects that needs scalar coupling capabilities.

Definition at line 32 of file ScalarCoupleable.h.

Constructor & Destructor Documentation

ScalarCoupleable() [1/2]

ScalarCoupleable::ScalarCoupleable

(

const MooseObject *

moose_object

)

Constructing the object.

Parameters

parameters

Parameters that come from constructing the object

Definition at line 19 of file ScalarCoupleable.C.

  : _sc_fe_problem(
        *moose_object->parameters().getCheckedPointerParam<FEProblemBase *>("_fe_problem_base")),
    _sc_tid(moose_object->parameters().isParamValid("_tid")
                ? moose_object->parameters().get<THREAD_ID>("_tid")
                : 0),
    _real_zero(_sc_fe_problem._real_zero[_sc_tid]),
    _scalar_zero(_sc_fe_problem._scalar_zero[_sc_tid]),
    _point_zero(_sc_fe_problem._point_zero[_sc_tid]),
    _sc_parameters(moose_object->parameters()),
    _sc_name(_sc_parameters.getObjectName()),
    _sc_is_implicit(_sc_parameters.have_parameter<bool>("implicit")
                        ? _sc_parameters.get<bool>("implicit")
                        : true)
{
  SubProblem & problem = *_sc_parameters.getCheckedPointerParam<SubProblem *>("_subproblem");
 
  // Coupling
  for (std::set<std::string>::const_iterator iter = _sc_parameters.coupledVarsBegin();
       iter != _sc_parameters.coupledVarsEnd();
       ++iter)
  {
    std::string name = *iter;
    if (_sc_parameters.getVecMooseType(*iter) != std::vector<std::string>())
    {
      std::vector<std::string> vars = _sc_parameters.getVecMooseType(*iter);
      for (const auto & coupled_var_name : vars)
      {
        if (problem.hasScalarVariable(coupled_var_name))
        {
          MooseVariableScalar * scalar_var = &problem.getScalarVariable(_sc_tid, coupled_var_name);
          _coupled_scalar_vars[name].push_back(scalar_var);
          _coupled_moose_scalar_vars.push_back(scalar_var);
        }
        else if (problem.hasVariable(coupled_var_name))
        {
          MooseVariableFEBase * moose_var =
              &problem.getVariable(_sc_tid,
                                   coupled_var_name,
                                   Moose::VarKindType::VAR_ANY,
                                   Moose::VarFieldType::VAR_FIELD_ANY);
          _sc_coupled_vars[name].push_back(moose_var);
        }
        else
          mooseError(_sc_name, ": Coupled variable '", coupled_var_name, "' was not found");
      }
    }
  }
}

ScalarCoupleable() [2/2]

ScalarCoupleable::ScalarCoupleable	(	const ScalarCoupleable &	object,
		const Moose::Kokkos::FunctorCopy &	key
	)

Special constructor used for Kokkos functor copy during parallel dispatch.

Definition at line 70 of file ScalarCoupleable.C.

  : _sc_fe_problem(object._sc_fe_problem),
    _sc_tid(object._sc_tid),
    _real_zero(object._real_zero),
    _scalar_zero(object._scalar_zero),
    _point_zero(object._point_zero),
    _sc_parameters(object._sc_parameters),
    _sc_name(object._sc_name),
    _sc_is_implicit(object._sc_is_implicit)
{
}

Member Function Documentation

adCoupledScalarDot()

const ADVariableValue & ScalarCoupleable::adCoupledScalarDot ( const std::string &  var_name, unsigned int  comp = 0  ) const

protected

Returns the time derivative of a scalar coupled variable, including its dependence on the nonlinear degrees of freedom through automatic differentiation.

Parameters

var_name	Name of coupled variable
comp	Component number for vector of coupled variables

Returns

Reference to the time derivative at quadrature points for the coupled variable, including automatic differentiation information

Definition at line 267 of file ScalarCoupleable.C.

{
  checkVar(var_name);
  validateExecutionerType(var_name, "adCoupledScalarDot");
  return getScalarVar(var_name, comp)->adUDot();
}

adCoupledScalarValue()

const ADVariableValue & ScalarCoupleable::adCoupledScalarValue ( const std::string &  var_name, unsigned int  comp = 0  ) const

protected

Returns AD value of a scalar coupled variable.

Parameters

var_name	Name of coupled variable
comp	Component number for vector of coupled variables

Returns

Reference to a ADVariableValue for the coupled variable

Definition at line 150 of file ScalarCoupleable.C.

{
  checkVar(var_name);
  if (!isCoupledScalar(var_name, comp))
    return *getADDefaultValue(var_name);
 
  auto var = getScalarVar(var_name, comp);
 
  if (_sc_is_implicit)
    return var->adSln();
  else
    mooseError("adCoupledValue for non-implicit calculations is not currently supported. Use "
               "coupledValue instead for non-implicit");
}

Referenced by coupledGenericScalarValue().

checkVar()

void ScalarCoupleable::checkVar ( const std::string &  var_name ) const

private

Check that the right kind of variable is being coupled in.

Parameters

var_name

The name of the coupled variable

Definition at line 315 of file ScalarCoupleable.C.

{
  const auto & var_name = _sc_parameters.checkForRename(var_name_in);
 
  auto it = _sc_coupled_vars.find(var_name);
  if (it != _sc_coupled_vars.end())
  {
    std::string cvars;
    for (auto jt : it->second)
      cvars += " " + jt->name();
    mooseError(_sc_name,
               ": Trying to couple a field variable where scalar variable is expected, '",
               var_name,
               " =",
               cvars,
               "'");
  }
  // NOTE: non-existent variables are handled in the constructor
}

Referenced by adCoupledScalarDot(), adCoupledScalarValue(), coupledMatrixTagScalarValue(), coupledScalar(), coupledScalarDot(), coupledScalarDotDot(), coupledScalarDotDotDu(), coupledScalarDotDotOld(), coupledScalarDotDu(), coupledScalarDotOld(), coupledScalarOrder(), coupledScalarValue(), coupledScalarValueOld(), coupledScalarValueOlder(), and coupledVectorTagScalarValue().

coupledGenericScalarValue() [1/3]

template<>

const GenericVariableValue< false > & ScalarCoupleable::coupledGenericScalarValue ( const std::string &  var_name, const unsigned int  comp  ) const

protected

Definition at line 166 of file ScalarCoupleable.C.

{
  return coupledScalarValue(var_name, comp);
}

coupledGenericScalarValue() [2/3]

template<>

const GenericVariableValue< true > & ScalarCoupleable::coupledGenericScalarValue ( const std::string &  var_name, const unsigned int  comp  ) const

protected

Definition at line 174 of file ScalarCoupleable.C.

{
  return adCoupledScalarValue(var_name, comp);
}

coupledGenericScalarValue() [3/3]

template<bool is_ad>

const GenericVariableValue< is_ad > & ScalarCoupleable::coupledGenericScalarValue ( const std::string &  var_name, unsigned int  comp = 0  ) const

protected

Returns value of a coupled scalar variable for use in templated automatic differentiation classes.

Parameters

var_name	Name of coupled scalar variable
comp	Component number for vector of coupled scalar variables

Returns

Reference to a GenericVariableValue for the coupled scalar variable

coupledMatrixTagScalarValue()

const VariableValue & ScalarCoupleable::coupledMatrixTagScalarValue ( const std::string &  var_name, TagID  tag, unsigned int  comp = 0  ) const

protected

Returns value of a scalar coupled variable.

Parameters

var_name	Name of coupled variable
tag	Tag ID of coupled matrix;
comp	Component number for vector of coupled variables

Returns

Reference to a VariableValue for the coupled variable

Definition at line 217 of file ScalarCoupleable.C.

{
  checkVar(var_name);
  if (!isCoupledScalar(var_name, comp))
    return *getDefaultValue(var_name);
 
  _sc_coupleable_matrix_tags.insert(tag);
 
  return getScalarVar(var_name, comp)->matrixTagSln(tag);
}

coupledScalar()

unsigned int ScalarCoupleable::coupledScalar ( const std::string &  var_name, unsigned int  comp = 0  ) const

protected

Returns the index for a scalar coupled variable by name.

Parameters

var_name	Name of coupled variable
comp	Component number for vector of coupled variables

Returns

Index of coupled variable

Definition at line 108 of file ScalarCoupleable.C.

{
  checkVar(var_name);
  return getScalarVar(var_name, comp)->number();
}

Referenced by ParsedODEKernel::ParsedODEKernel().

coupledScalarComponents()

unsigned int ScalarCoupleable::coupledScalarComponents ( const std::string &  var_name ) const

protected

Return the number of components to the coupled scalar variable.

Parameters

var_name

The of the coupled variable

Definition at line 368 of file ScalarCoupleable.C.

{
  const auto & var_name = _sc_parameters.checkForRename(var_name_in);
 
  const auto it = _coupled_scalar_vars.find(var_name);
  if (it != _coupled_scalar_vars.end())
    return it->second.size();
 
  mooseError(_sc_name, ": Trying to get a non-existent variable '", var_name, "'");
}

coupledScalarDot()

const VariableValue & ScalarCoupleable::coupledScalarDot ( const std::string &  var_name, unsigned int  comp = 0  ) const

protected

Returns the time derivative of a scalar coupled variable.

Parameters

var_name	Name of coupled variable
comp	Component number for vector of coupled variables

Returns

Reference to a time derivative VariableValue for the coupled variable

Definition at line 259 of file ScalarCoupleable.C.

{
  checkVar(var_name);
  validateExecutionerType(var_name, "coupledScalarDot");
  return getScalarVar(var_name, comp)->uDot();
}

coupledScalarDotDot()

const VariableValue & ScalarCoupleable::coupledScalarDotDot ( const std::string &  var_name, unsigned int  comp = 0  ) const

protected

Returns the second time derivative of a scalar coupled variable.

Parameters

var_name	Name of coupled variable
comp	Component number for vector of coupled variables

Returns

Reference to a time derivative VariableValue for the coupled variable

Definition at line 275 of file ScalarCoupleable.C.

{
  checkVar(var_name);
  validateExecutionerType(var_name, "coupledScalarDotDot");
  return getScalarVar(var_name, comp)->uDotDot();
}

coupledScalarDotDotDu()

const VariableValue & ScalarCoupleable::coupledScalarDotDotDu ( const std::string &  var_name, unsigned int  comp = 0  ) const

protected

Second time derivative of a scalar coupled variable with respect to the coefficients.

Parameters

var_name	Name of coupled variable
comp	Component number for vector of coupled variables

Returns

Reference to a VariableValue containing the time derivative of the coupled variable with respect to the coefficients

Definition at line 307 of file ScalarCoupleable.C.

{
  checkVar(var_name);
  validateExecutionerType(var_name, "coupledScalarDotDotDu");
  return getScalarVar(var_name, comp)->duDotDotDu();
}

coupledScalarDotDotOld()

const VariableValue & ScalarCoupleable::coupledScalarDotDotOld ( const std::string &  var_name, unsigned int  comp = 0  ) const

protected

Returns the old second time derivative of a scalar coupled variable.

Parameters

var_name	Name of coupled variable
comp	Component number for vector of coupled variables

Returns

Reference to a time derivative VariableValue for the coupled variable

Definition at line 291 of file ScalarCoupleable.C.

{
  checkVar(var_name);
  validateExecutionerType(var_name, "coupledScalarDotDotOld");
  return getScalarVar(var_name, comp)->uDotDotOld();
}

coupledScalarDotDu()

const VariableValue & ScalarCoupleable::coupledScalarDotDu ( const std::string &  var_name, unsigned int  comp = 0  ) const

protected

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

Parameters

var_name	Name of coupled variable
comp	Component number for vector of coupled variables

Returns

Reference to a VariableValue containing the time derivative of the coupled variable with respect to the coefficients

Definition at line 299 of file ScalarCoupleable.C.

{
  checkVar(var_name);
  validateExecutionerType(var_name, "coupledScalarDotDu");
  return getScalarVar(var_name, comp)->duDotDu();
}

coupledScalarDotOld()

const VariableValue & ScalarCoupleable::coupledScalarDotOld ( const std::string &  var_name, unsigned int  comp = 0  ) const

protected

Returns the old time derivative of a scalar coupled variable.

Parameters

var_name	Name of coupled variable
comp	Component number for vector of coupled variables

Returns

Reference to a time derivative VariableValue for the coupled variable

Definition at line 283 of file ScalarCoupleable.C.

{
  checkVar(var_name);
  validateExecutionerType(var_name, "coupledScalarDotOld");
  return getScalarVar(var_name, comp)->uDotOld();
}

coupledScalarOrder()

Order ScalarCoupleable::coupledScalarOrder ( const std::string &  var_name, unsigned int  comp = 0  ) const

protected

Returns the order for a scalar coupled variable by name.

Parameters

var_name	Name of coupled variable
comp	Component number for vector of coupled variables

Returns

Order of coupled variable

Definition at line 115 of file ScalarCoupleable.C.

{
  checkVar(var_name);
  if (!isCoupledScalar(var_name, comp))
    return _sc_fe_problem.getMaxScalarOrder();
 
  return getScalarVar(var_name, comp)->order();
}

coupledScalarValue()

const VariableValue & ScalarCoupleable::coupledScalarValue ( const std::string &  var_name, unsigned int  comp = 0  ) const

protected

Returns value of a scalar coupled variable.

Parameters

var_name	Name of coupled variable
comp	Component number for vector of coupled variables

Returns

Reference to a VariableValue for the coupled variable

Definition at line 139 of file ScalarCoupleable.C.

{
  checkVar(var_name);
  if (!isCoupledScalar(var_name, comp))
    return *getDefaultValue(var_name);
 
  auto var = getScalarVar(var_name, comp);
  return _sc_is_implicit ? var->sln() : var->slnOld();
}

Referenced by coupledGenericScalarValue(), and ParsedODEKernel::ParsedODEKernel().

coupledScalarValueOld()

const VariableValue & ScalarCoupleable::coupledScalarValueOld ( const std::string &  var_name, unsigned int  comp = 0  ) const

protected

Returns the old (previous time step) value of a scalar coupled variable.

Parameters

var_name	Name of coupled variable
comp	Component number for vector of coupled variables

Returns

Reference to a old VariableValue for the coupled variable

Definition at line 231 of file ScalarCoupleable.C.

{
  checkVar(var_name);
  if (!isCoupledScalar(var_name, comp))
    return *getDefaultValue(var_name);
 
  validateExecutionerType(var_name, "coupledScalarValueOld");
  auto var = getScalarVar(var_name, comp);
  return _sc_is_implicit ? var->slnOld() : var->slnOlder();
}

coupledScalarValueOlder()

const VariableValue & ScalarCoupleable::coupledScalarValueOlder ( const std::string &  var_name, unsigned int  comp = 0  ) const

protected

Returns the older (two time steps previous) value of a scalar coupled variable.

Parameters

var_name	Name of coupled variable
comp	Component number for vector of coupled variables

Returns

Reference to a older VariableValue for the coupled variable

Definition at line 243 of file ScalarCoupleable.C.

{
  checkVar(var_name);
  if (!isCoupledScalar(var_name, comp))
    return *getDefaultValue(var_name);
 
  validateExecutionerType(var_name, "coupledScalarValueOlder");
  auto var = getScalarVar(var_name, comp);
  if (_sc_is_implicit)
    return var->slnOlder();
  else
    mooseError("Older values not available for explicit schemes");
}

coupledVectorTagScalarValue()

const VariableValue & ScalarCoupleable::coupledVectorTagScalarValue ( const std::string &  var_name, TagID  tag, unsigned int  comp = 0  ) const

protected

Returns value of a scalar coupled variable.

Parameters

var_name	Name of coupled variable
tag	Tag ID of coupled vector ;
comp	Component number for vector of coupled variables

Returns

Reference to a VariableValue for the coupled variable

Definition at line 196 of file ScalarCoupleable.C.

{
  checkVar(var_name);
  if (!isCoupledScalar(var_name, comp))
    return *getDefaultValue(var_name);
 
  if (!_sc_fe_problem.vectorTagExists(tag))
    mooseError("Attempting to couple to vector tag scalar with ID ",
               tag,
               "in ",
               _sc_name,
               ", but a vector tag with that ID does not exist");
 
  _sc_coupleable_vector_tags.insert(tag);
 
  return getScalarVar(var_name, comp)->vectorTagSln(tag);
}

getADDefaultValue()

const ADVariableValue * ScalarCoupleable::getADDefaultValue ( const std::string &  var_name ) const

private

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

Parameters

var_name

the name of the variable for which to retrieve a default value

Returns

ADVariableValue * a pointer to the associated ADVariableValue.

Definition at line 182 of file ScalarCoupleable.C.

{
  auto default_value_it = _dual_default_value.find(var_name);
  if (default_value_it == _dual_default_value.end())
  {
    auto value = std::make_unique<ADVariableValue>(_sc_fe_problem.getMaxScalarOrder(),
                                                   _sc_parameters.defaultCoupledValue(var_name));
    default_value_it = _dual_default_value.insert(std::make_pair(var_name, std::move(value))).first;
  }
 
  return default_value_it->second.get();
}

Referenced by adCoupledScalarValue().

getCoupledMooseScalarVars()

const std::vector< MooseVariableScalar * > & ScalarCoupleable::getCoupledMooseScalarVars ( )

inline

Get the list of coupled scalar variables.

Returns

The list of coupled variables

Definition at line 52 of file ScalarCoupleable.h.

  {
    return _coupled_moose_scalar_vars;
  }

Referenced by AuxScalarKernel::AuxScalarKernel(), MortarScalarBase::computeJacobian(), KernelScalarBase::computeResidualAndJacobian(), and ScalarInitialCondition::ScalarInitialCondition().

getDefaultValue()

const VariableValue * ScalarCoupleable::getDefaultValue ( const std::string &  var_name ) const

private

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

Parameters

var_name

the name of the variable for which to retrieve a default value

Returns

VariableValue * a pointer to the associated VariableValue.

Definition at line 125 of file ScalarCoupleable.C.

{
  auto default_value_it = _default_value.find(var_name);
  if (default_value_it == _default_value.end())
  {
    auto value = std::make_unique<VariableValue>(_sc_fe_problem.getMaxScalarOrder(),
                                                 _sc_parameters.defaultCoupledValue(var_name));
    default_value_it = _default_value.insert(std::make_pair(var_name, std::move(value))).first;
  }
 
  return default_value_it->second.get();
}

Referenced by coupledMatrixTagScalarValue(), coupledScalarValue(), coupledScalarValueOld(), coupledScalarValueOlder(), and coupledVectorTagScalarValue().

getScalarVar()

const MooseVariableScalar * ScalarCoupleable::getScalarVar ( const std::string &  var_name, unsigned int  comp  ) const

protected

Extract pointer to a scalar coupled variable.

Parameters

var_name	Name of parameter desired
comp	Component number of multiple coupled variables

Returns

Pointer to the desired variable

Definition at line 336 of file ScalarCoupleable.C.

{
  const auto & var_name = _sc_parameters.checkForRename(var_name_in);
 
  const auto it = _coupled_scalar_vars.find(var_name);
  if (it != _coupled_scalar_vars.end())
  {
    const auto & entry = it->second;
    if (comp < entry.size())
      return entry[comp];
    else
      mooseError(_sc_name, ": Trying to get a non-existent component of variable '", var_name, "'");
  }
  else
    mooseError(_sc_name, ": Trying to get a non-existent variable '", var_name, "'");
}

Referenced by adCoupledScalarDot(), adCoupledScalarValue(), coupledMatrixTagScalarValue(), coupledScalar(), coupledScalarDot(), coupledScalarDotDot(), coupledScalarDotDotDu(), coupledScalarDotDotOld(), coupledScalarDotDu(), coupledScalarDotOld(), coupledScalarOrder(), coupledScalarValue(), coupledScalarValueOld(), coupledScalarValueOlder(), coupledVectorTagScalarValue(), and ParsedODEKernel::ParsedODEKernel().

getScalarVariableCoupleableMatrixTags()

const std::set< TagID > & ScalarCoupleable::getScalarVariableCoupleableMatrixTags ( ) const

inline

Definition at line 62 of file ScalarCoupleable.h.

  {
    return _sc_coupleable_matrix_tags;
  }

getScalarVariableCoupleableVectorTags()

const std::set< TagID > & ScalarCoupleable::getScalarVariableCoupleableVectorTags ( ) const

inline

Definition at line 57 of file ScalarCoupleable.h.

  {
    return _sc_coupleable_vector_tags;
  }

isCoupledScalar()

bool ScalarCoupleable::isCoupledScalar ( const std::string &  var_name, unsigned int  i = 0  ) const

protected

Returns true if a variables has been coupled_as name.

Parameters

var_name	The of the coupled variable
i	By default 0, in general the index to test in a vector of MooseVariable pointers.

Definition at line 85 of file ScalarCoupleable.C.

{
  const auto & var_name = _sc_parameters.checkForRename(var_name_in);
 
  auto it = _coupled_scalar_vars.find(var_name);
  if (it != _coupled_scalar_vars.end())
    return (i < it->second.size());
  else
  {
    // Make sure the user originally requested this value in the InputParameter syntax
    if (!_sc_parameters.hasCoupledVar(var_name))
      mooseError(_sc_name,
                 ": The coupled scalar variable \"",
                 var_name,
                 "\" was never added to this object's "
                 "InputParameters, please double-check "
                 "your spelling");
 
    return false;
  }
}

Referenced by adCoupledScalarValue(), coupledMatrixTagScalarValue(), coupledScalarOrder(), coupledScalarValue(), coupledScalarValueOld(), coupledScalarValueOlder(), and coupledVectorTagScalarValue().

validateExecutionerType()

void ScalarCoupleable::validateExecutionerType ( const std::string &  name, const std::string &  fn_name  ) const

private

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

Parameters

name	the name of the variable
fn_name	The name of the function that called this method - used in the error message

Definition at line 354 of file ScalarCoupleable.C.

{
  if (!_sc_fe_problem.isTransient())
    mooseError(_sc_name,
               ": Calling '",
               fn_name,
               "' on variable \"",
               name,
               "\" when using a \"Steady\" executioner is not allowed. This value is available "
               "only in transient simulations.");
}

Referenced by adCoupledScalarDot(), coupledScalarDot(), coupledScalarDotDot(), coupledScalarDotDotDu(), coupledScalarDotDotOld(), coupledScalarDotDu(), coupledScalarDotOld(), coupledScalarValueOld(), and coupledScalarValueOlder().

Member Data Documentation

_coupled_moose_scalar_vars

std::vector<MooseVariableScalar *> ScalarCoupleable::_coupled_moose_scalar_vars

private

Vector of coupled variables.

Definition at line 304 of file ScalarCoupleable.h.

Referenced by getCoupledMooseScalarVars(), and ScalarCoupleable().

_coupled_scalar_vars

std::unordered_map<std::string, std::vector<MooseVariableScalar *> > ScalarCoupleable::_coupled_scalar_vars

private

Coupled vars whose values we provide.

Definition at line 295 of file ScalarCoupleable.h.

Referenced by coupledScalarComponents(), getScalarVar(), isCoupledScalar(), and ScalarCoupleable().

_default_value

std::unordered_map<std::string, std::unique_ptr<VariableValue> > ScalarCoupleable::_default_value

mutableprivate

Will hold the default value for optional coupled scalar variables.

Definition at line 298 of file ScalarCoupleable.h.

Referenced by getDefaultValue().

_dual_default_value

std::unordered_map<std::string, std::unique_ptr<ADVariableValue> > ScalarCoupleable::_dual_default_value

mutableprivate

Will hold the default AD value for optional coupled scalar variables.

Definition at line 301 of file ScalarCoupleable.h.

Referenced by getADDefaultValue().

_point_zero

const Point& ScalarCoupleable::_point_zero

protected

Zero point.

Definition at line 251 of file ScalarCoupleable.h.

Referenced by FunctionDT::computeDT(), FunctionScalarAux::computeValue(), and FunctionScalarIC::value().

_real_zero

const Real& ScalarCoupleable::_real_zero

protected

Scalar zero.

Definition at line 245 of file ScalarCoupleable.h.

_sc_coupleable_matrix_tags

std::set<TagID> ScalarCoupleable::_sc_coupleable_matrix_tags

mutableprivate

The scalar coupleable matrix tags.

Definition at line 312 of file ScalarCoupleable.h.

Referenced by coupledMatrixTagScalarValue(), and getScalarVariableCoupleableMatrixTags().

_sc_coupleable_vector_tags

std::set<TagID> ScalarCoupleable::_sc_coupleable_vector_tags

mutableprivate

The scalar coupleable vector tags.

Definition at line 310 of file ScalarCoupleable.h.

Referenced by coupledVectorTagScalarValue(), and getScalarVariableCoupleableVectorTags().

_sc_coupled_vars

std::unordered_map<std::string, std::vector<MooseVariableFieldBase *> > ScalarCoupleable::_sc_coupled_vars

private

Field variables coupled into this object (for error checking)

Definition at line 307 of file ScalarCoupleable.h.

Referenced by checkVar(), and ScalarCoupleable().

_sc_fe_problem

FEProblemBase& ScalarCoupleable::_sc_fe_problem

protected

Definition at line 239 of file ScalarCoupleable.h.

Referenced by coupledScalarOrder(), coupledVectorTagScalarValue(), getADDefaultValue(), getDefaultValue(), and validateExecutionerType().

_sc_is_implicit

const bool ScalarCoupleable::_sc_is_implicit

private

True if implicit value is required.

Definition at line 292 of file ScalarCoupleable.h.

Referenced by adCoupledScalarValue(), coupledScalarValue(), coupledScalarValueOld(), and coupledScalarValueOlder().

_sc_name

const std::string& ScalarCoupleable::_sc_name

private

The name of the object this interface is part of.

Definition at line 289 of file ScalarCoupleable.h.

Referenced by checkVar(), coupledScalarComponents(), coupledVectorTagScalarValue(), getScalarVar(), isCoupledScalar(), ScalarCoupleable(), and validateExecutionerType().

_sc_parameters

const InputParameters& ScalarCoupleable::_sc_parameters

private

Definition at line 286 of file ScalarCoupleable.h.

Referenced by checkVar(), coupledScalarComponents(), getADDefaultValue(), getDefaultValue(), getScalarVar(), isCoupledScalar(), and ScalarCoupleable().

_sc_tid

const THREAD_ID ScalarCoupleable::_sc_tid

protected

Thread ID of the thread using this object.

Definition at line 242 of file ScalarCoupleable.h.

Referenced by ScalarCoupleable().

_scalar_zero

const VariableValue& ScalarCoupleable::_scalar_zero

protected

Zero value of a scalar variable.

Definition at line 248 of file ScalarCoupleable.h.

---

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

• include/interfaces/ScalarCoupleable.h
• src/interfaces/ScalarCoupleable.C