ScalarCoupleable::ScalarCoupleable(const InputParameters & parameters) :
_sc_is_implicit(parameters.have_parameter<bool>("implicit") ? parameters.get<bool>("implicit") : true)
{
SubProblem & problem = *parameters.get<SubProblem *>("_subproblem");
THREAD_ID tid = parameters.have_parameter<THREAD_ID>("_tid") ? parameters.get<THREAD_ID>("_tid") : 0;
// Coupling
for (std::set<std::string>::const_iterator iter = parameters.coupledVarsBegin();
iter != parameters.coupledVarsEnd();
++iter)
{
std::string name = *iter;
if (parameters.getVecMooseType(*iter) != std::vector<std::string>())
{
std::vector<std::string> vars = parameters.getVecMooseType(*iter);
for (unsigned int i = 0; i < vars.size(); i++)
{
std::string coupled_var_name = vars[i];
if (problem.hasScalarVariable(coupled_var_name))
{
MooseVariableScalar * scalar_var = &problem.getScalarVariable(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))
; // ignore normal variables
else
mooseError("Coupled variable '" + coupled_var_name + "' was not found\n");
}
}
}
}
void
InputParameters::applyParameters(const InputParameters & common)
{
// Disable the display of deprecated message when applying common parameters, this avoids a dump of messages
_show_deprecated_message = false;
// Loop through the common parameters
for (InputParameters::const_iterator it = common.begin(); it != common.end(); ++it)
{
// Common parameter name
const std::string & common_name = it->first;
// Extract the properties from the local parameter for the current common parameter name
bool local_exist = _values.find(common_name) != _values.end();
bool local_set = _set_by_add_param.find(common_name) == _set_by_add_param.end();
bool local_priv = isPrivate(common_name);
bool local_valid = isParamValid(common_name);
// Extract the properties from the common parameter
bool common_valid = common.isParamValid(common_name);
bool common_priv = common.isPrivate(common_name);
/* In order to apply common parameter 4 statements must be satisfied
* (1) A local parameter must exist with the same name as common parameter
* (2) Common parameter must valid
* (3) Local parameter must be invalid OR not have been set from its default
* (4) Neither may be private
*/
if ( local_exist && common_valid && (!local_valid || !local_set) && (!common_priv || !local_priv))
{
delete _values[common_name];
_values[common_name] = it->second->clone();
set_attributes(common_name, false);
}
}
// Loop through the coupled variables
for (std::set<std::string>::const_iterator it = common.coupledVarsBegin(); it != common.coupledVarsEnd(); ++it)
{
// If the local parameters has a coupled variable, populate it with the value from the common parameters
const std::string var_name = *it;
if (hasCoupledValue(var_name))
{
if (common.hasDefaultCoupledValue(var_name))
addCoupledVar(var_name, common.defaultCoupledValue(var_name), common.getDocString(var_name));
else
addCoupledVar(var_name, common.getDocString(var_name));
}
}
// Enable deprecated message printing
_show_deprecated_message = true;
}
Coupleable::Coupleable(const InputParameters & parameters, bool nodal) :
_c_fe_problem(*parameters.getCheckedPointerParam<FEProblem *>("_fe_problem")),
_nodal(nodal),
_c_is_implicit(parameters.have_parameter<bool>("implicit") ? parameters.get<bool>("implicit") : true),
_coupleable_params(parameters)
{
SubProblem & problem = *parameters.get<SubProblem *>("_subproblem");
_coupleable_max_qps = _c_fe_problem.getMaxQps();
THREAD_ID tid = parameters.get<THREAD_ID>("_tid");
// Coupling
for (std::set<std::string>::const_iterator iter = parameters.coupledVarsBegin();
iter != parameters.coupledVarsEnd();
++iter)
{
std::string name = *iter;
if (parameters.getVecMooseType(name) != std::vector<std::string>())
{
std::vector<std::string> vars = parameters.getVecMooseType(*iter);
for (unsigned int i = 0; i < vars.size(); i++)
{
std::string coupled_var_name = vars[i];
if (problem.hasVariable(coupled_var_name))
{
MooseVariable * moose_var = &problem.getVariable(tid, coupled_var_name);
_coupled_vars[name].push_back(moose_var);
_coupled_moose_vars.push_back(moose_var);
}
else if (problem.hasScalarVariable(coupled_var_name))
; // ignore scalar variables
else
mooseError("Coupled variable '" + coupled_var_name + "' was not found\n");
}
}
else // This means it was optional coupling. Let's assign a unique id to this variable
_optional_var_index[name] = std::numeric_limits<unsigned int>::max() - _optional_var_index.size();
}
_default_value_zero.resize(_coupleable_max_qps);
_default_gradient.resize(_coupleable_max_qps);
_default_second.resize(_coupleable_max_qps);
}
