NodalKernel::NodalKernel(const InputParameters & parameters) :
MooseObject(parameters),
BlockRestrictable(parameters),
SetupInterface(parameters),
FunctionInterface(parameters),
UserObjectInterface(parameters),
TransientInterface(parameters, "bcs"),
PostprocessorInterface(parameters),
GeometricSearchInterface(parameters),
Restartable(parameters, "BCs"),
ZeroInterface(parameters),
MeshChangedInterface(parameters),
RandomInterface(parameters, *parameters.get<FEProblem *>("_fe_problem"), parameters.get<THREAD_ID>("_tid"), true),
CoupleableMooseVariableDependencyIntermediateInterface(parameters, true),
_subproblem(*parameters.get<SubProblem *>("_subproblem")),
_fe_problem(*parameters.get<FEProblem *>("_fe_problem")),
_sys(*parameters.get<SystemBase *>("_sys")),
_tid(parameters.get<THREAD_ID>("_tid")),
_assembly(_subproblem.assembly(_tid)),
_var(_sys.getVariable(_tid, parameters.get<NonlinearVariableName>("variable"))),
_mesh(_subproblem.mesh()),
_current_node(_var.node()),
_u(_var.nodalSln()),
_u_dot(_var.nodalSlnDot()),
_du_dot_du(_var.nodalSlnDuDotDu()),
_save_in_strings(parameters.get<std::vector<AuxVariableName> >("save_in")),
_diag_save_in_strings(parameters.get<std::vector<AuxVariableName> >("diag_save_in"))
{
_save_in.resize(_save_in_strings.size());
_diag_save_in.resize(_diag_save_in_strings.size());
for (unsigned int i=0; i<_save_in_strings.size(); i++)
{
MooseVariable * var = &_subproblem.getVariable(_tid, _save_in_strings[i]);
if (var->feType() != _var.feType())
mooseError("Error in " + name() + ". When saving residual values in an Auxiliary variable the AuxVariable must be the same type as the nonlinear variable the object is acting on.");
_save_in[i] = var;
var->sys().addVariableToZeroOnResidual(_save_in_strings[i]);
addMooseVariableDependency(var);
}
_has_save_in = _save_in.size() > 0;
for (unsigned int i=0; i<_diag_save_in_strings.size(); i++)
{
MooseVariable * var = &_subproblem.getVariable(_tid, _diag_save_in_strings[i]);
if (var->feType() != _var.feType())
mooseError("Error in " + name() + ". When saving diagonal Jacobian values in an Auxiliary variable the AuxVariable must be the same type as the nonlinear variable the object is acting on.");
_diag_save_in[i] = var;
var->sys().addVariableToZeroOnJacobian(_diag_save_in_strings[i]);
addMooseVariableDependency(var);
}
_has_diag_save_in = _diag_save_in.size() > 0;
}
Kernel::Kernel(const InputParameters & parameters)
: KernelBase(parameters),
MooseVariableInterface<Real>(this, false),
_var(*mooseVariable()),
_test(_var.phi()),
_grad_test(_var.gradPhi()),
_phi(_assembly.phi(_var)),
_grad_phi(_assembly.gradPhi(_var)),
_u(_is_implicit ? _var.sln() : _var.slnOld()),
_grad_u(_is_implicit ? _var.gradSln() : _var.gradSlnOld()),
_u_dot(_var.uDot()),
_du_dot_du(_var.duDotDu())
{
addMooseVariableDependency(mooseVariable());
_save_in.resize(_save_in_strings.size());
_diag_save_in.resize(_diag_save_in_strings.size());
for (unsigned int i = 0; i < _save_in_strings.size(); i++)
{
MooseVariable * var = &_subproblem.getStandardVariable(_tid, _save_in_strings[i]);
if (_fe_problem.getNonlinearSystemBase().hasVariable(_save_in_strings[i]))
paramError("save_in", "cannot use solution variable as save-in variable");
if (var->feType() != _var.feType())
paramError(
"save_in",
"saved-in auxiliary variable is incompatible with the object's nonlinear variable: ",
moose::internal::incompatVarMsg(*var, _var));
_save_in[i] = var;
var->sys().addVariableToZeroOnResidual(_save_in_strings[i]);
addMooseVariableDependency(var);
}
_has_save_in = _save_in.size() > 0;
for (unsigned int i = 0; i < _diag_save_in_strings.size(); i++)
{
MooseVariable * var = &_subproblem.getStandardVariable(_tid, _diag_save_in_strings[i]);
if (_fe_problem.getNonlinearSystemBase().hasVariable(_diag_save_in_strings[i]))
paramError("diag_save_in", "cannot use solution variable as diag save-in variable");
if (var->feType() != _var.feType())
paramError(
"diag_save_in",
"saved-in auxiliary variable is incompatible with the object's nonlinear variable: ",
moose::internal::incompatVarMsg(*var, _var));
_diag_save_in[i] = var;
var->sys().addVariableToZeroOnJacobian(_diag_save_in_strings[i]);
addMooseVariableDependency(var);
}
_has_diag_save_in = _diag_save_in.size() > 0;
}
ADIntegratedBCTempl<T, compute_stage>::ADIntegratedBCTempl(const InputParameters & parameters)
: IntegratedBCBase(parameters),
MooseVariableInterface<T>(this,
false,
"variable",
Moose::VarKindType::VAR_NONLINEAR,
std::is_same<T, Real>::value ? Moose::VarFieldType::VAR_FIELD_STANDARD
: Moose::VarFieldType::VAR_FIELD_VECTOR),
_var(*this->mooseVariable()),
_normals(_assembly.adNormals<compute_stage>()),
_ad_q_points(_assembly.adQPointsFace<compute_stage>()),
_test(_var.phiFace()),
_grad_test(_var.template adGradPhiFace<compute_stage>()),
_u(_var.template adSln<compute_stage>()),
_grad_u(_var.template adGradSln<compute_stage>()),
_ad_JxW(_assembly.adJxWFace<compute_stage>())
{
addMooseVariableDependency(this->mooseVariable());
_save_in.resize(_save_in_strings.size());
_diag_save_in.resize(_diag_save_in_strings.size());
for (unsigned int i = 0; i < _save_in_strings.size(); i++)
{
MooseVariable * var = &_subproblem.getStandardVariable(_tid, _save_in_strings[i]);
if (var->feType() != _var.feType())
paramError(
"save_in",
"saved-in auxiliary variable is incompatible with the object's nonlinear variable: ",
moose::internal::incompatVarMsg(*var, _var));
_save_in[i] = var;
var->sys().addVariableToZeroOnResidual(_save_in_strings[i]);
addMooseVariableDependency(var);
}
_has_save_in = _save_in.size() > 0;
for (unsigned int i = 0; i < _diag_save_in_strings.size(); i++)
{
MooseVariable * var = &_subproblem.getStandardVariable(_tid, _diag_save_in_strings[i]);
if (var->feType() != _var.feType())
paramError(
"diag_save_in",
"saved-in auxiliary variable is incompatible with the object's nonlinear variable: ",
moose::internal::incompatVarMsg(*var, _var));
_diag_save_in[i] = var;
var->sys().addVariableToZeroOnJacobian(_diag_save_in_strings[i]);
addMooseVariableDependency(var);
}
_has_diag_save_in = _diag_save_in.size() > 0;
}
IntegratedBC::IntegratedBC(const InputParameters & parameters)
: IntegratedBCBase(parameters),
MooseVariableInterface<Real>(this,
false,
"variable",
Moose::VarKindType::VAR_NONLINEAR,
Moose::VarFieldType::VAR_FIELD_STANDARD),
_var(*mooseVariable()),
_normals(_var.normals()),
_phi(_assembly.phiFace(_var)),
_grad_phi(_assembly.gradPhiFace(_var)),
_test(_var.phiFace()),
_grad_test(_var.gradPhiFace()),
_u(_is_implicit ? _var.sln() : _var.slnOld()),
_grad_u(_is_implicit ? _var.gradSln() : _var.gradSlnOld())
{
addMooseVariableDependency(mooseVariable());
_save_in.resize(_save_in_strings.size());
_diag_save_in.resize(_diag_save_in_strings.size());
for (unsigned int i = 0; i < _save_in_strings.size(); i++)
{
MooseVariable * var = &_subproblem.getStandardVariable(_tid, _save_in_strings[i]);
if (var->feType() != _var.feType())
paramError(
"save_in",
"saved-in auxiliary variable is incompatible with the object's nonlinear variable: ",
moose::internal::incompatVarMsg(*var, _var));
_save_in[i] = var;
var->sys().addVariableToZeroOnResidual(_save_in_strings[i]);
addMooseVariableDependency(var);
}
_has_save_in = _save_in.size() > 0;
for (unsigned int i = 0; i < _diag_save_in_strings.size(); i++)
{
MooseVariable * var = &_subproblem.getStandardVariable(_tid, _diag_save_in_strings[i]);
if (var->feType() != _var.feType())
paramError(
"diag_save_in",
"saved-in auxiliary variable is incompatible with the object's nonlinear variable: ",
moose::internal::incompatVarMsg(*var, _var));
_diag_save_in[i] = var;
var->sys().addVariableToZeroOnJacobian(_diag_save_in_strings[i]);
addMooseVariableDependency(var);
}
_has_diag_save_in = _diag_save_in.size() > 0;
}
NodalBC::NodalBC(const InputParameters & parameters)
: NodalBCBase(parameters),
MooseVariableInterface<Real>(this,
true,
"variable",
Moose::VarKindType::VAR_NONLINEAR,
Moose::VarFieldType::VAR_FIELD_STANDARD),
_var(*mooseVariable()),
_current_node(_var.node()),
_u(_var.dofValues())
{
addMooseVariableDependency(mooseVariable());
_save_in.resize(_save_in_strings.size());
_diag_save_in.resize(_diag_save_in_strings.size());
for (unsigned int i = 0; i < _save_in_strings.size(); i++)
{
MooseVariable * var = &_subproblem.getStandardVariable(_tid, _save_in_strings[i]);
if (var->feType() != _var.feType())
paramError(
"save_in",
"saved-in auxiliary variable is incompatible with the object's nonlinear variable: ",
moose::internal::incompatVarMsg(*var, _var));
_save_in[i] = var;
var->sys().addVariableToZeroOnResidual(_save_in_strings[i]);
addMooseVariableDependency(var);
}
_has_save_in = _save_in.size() > 0;
for (unsigned int i = 0; i < _diag_save_in_strings.size(); i++)
{
MooseVariable * var = &_subproblem.getStandardVariable(_tid, _diag_save_in_strings[i]);
if (var->feType() != _var.feType())
paramError(
"diag_save_in",
"saved-in auxiliary variable is incompatible with the object's nonlinear variable: ",
moose::internal::incompatVarMsg(*var, _var));
_diag_save_in[i] = var;
var->sys().addVariableToZeroOnJacobian(_diag_save_in_strings[i]);
addMooseVariableDependency(var);
}
_has_diag_save_in = _diag_save_in.size() > 0;
}
NodalBC::NodalBC(const InputParameters & parameters) :
BoundaryCondition(parameters),
RandomInterface(parameters, _fe_problem, _tid, true),
CoupleableMooseVariableDependencyIntermediateInterface(parameters, true),
_current_node(_var.node()),
_u(_var.nodalSln()),
_save_in_strings(parameters.get<std::vector<AuxVariableName> >("save_in")),
_diag_save_in_strings(parameters.get<std::vector<AuxVariableName> >("diag_save_in"))
{
_save_in.resize(_save_in_strings.size());
_diag_save_in.resize(_diag_save_in_strings.size());
for (unsigned int i=0; i<_save_in_strings.size(); i++)
{
MooseVariable * var = &_subproblem.getVariable(_tid, _save_in_strings[i]);
if (var->feType() != _var.feType())
mooseError("Error in " + name() + ". When saving residual values in an Auxiliary variable the AuxVariable must be the same type as the nonlinear variable the object is acting on.");
_save_in[i] = var;
var->sys().addVariableToZeroOnResidual(_save_in_strings[i]);
addMooseVariableDependency(var);
}
_has_save_in = _save_in.size() > 0;
for (unsigned int i=0; i<_diag_save_in_strings.size(); i++)
{
MooseVariable * var = &_subproblem.getVariable(_tid, _diag_save_in_strings[i]);
if (var->feType() != _var.feType())
mooseError("Error in " + name() + ". When saving diagonal Jacobian values in an Auxiliary variable the AuxVariable must be the same type as the nonlinear variable the object is acting on.");
_diag_save_in[i] = var;
var->sys().addVariableToZeroOnJacobian(_diag_save_in_strings[i]);
addMooseVariableDependency(var);
}
_has_diag_save_in = _diag_save_in.size() > 0;
}
void
AuxiliarySystem::addVariable(const std::string & var_name, const FEType & type, Real scale_factor, const std::set< SubdomainID > * const active_subdomains/* = NULL*/)
{
SystemTempl<TransientExplicitSystem>::addVariable(var_name, type, scale_factor, active_subdomains);
for (THREAD_ID tid = 0; tid < libMesh::n_threads(); tid++)
{
MooseVariable * var = dynamic_cast<MooseVariable *>(_vars[tid].getVariable(var_name));
if (var != NULL)
{
if (var->feType().family == LAGRANGE)
_nodal_vars[tid][var_name] = var;
else
_elem_vars[tid][var_name] = var;
}
}
}
void
AuxiliarySystem::addVariable(const std::string & var_name,
const FEType & type,
Real scale_factor,
const std::set<SubdomainID> * const active_subdomains /* = NULL*/)
{
SystemBase::addVariable(var_name, type, scale_factor, active_subdomains);
for (THREAD_ID tid = 0; tid < libMesh::n_threads(); tid++)
{
MooseVariable * var = _vars[tid].getFieldVariable<Real>(var_name);
if (var != NULL)
{
if (var->feType().family == LAGRANGE)
_nodal_vars[tid][var_name] = var;
else
_elem_vars[tid][var_name] = var;
}
}
}
IntegratedBC::IntegratedBC(const std::string & name, InputParameters parameters) :
BoundaryCondition(name, parameters),
RandomInterface(name, parameters, _fe_problem, _tid, false),
CoupleableMooseVariableDependencyIntermediateInterface(parameters, false),
MaterialPropertyInterface(parameters),
_current_elem(_assembly.elem()),
_current_elem_volume(_assembly.elemVolume()),
_current_side(_assembly.side()),
_current_side_elem(_assembly.sideElem()),
_current_side_volume(_assembly.sideElemVolume()),
_normals(_var.normals()),
_qrule(_assembly.qRuleFace()),
_q_point(_assembly.qPointsFace()),
_JxW(_assembly.JxWFace()),
_coord(_assembly.coordTransformation()),
_phi(_assembly.phiFace()),
_grad_phi(_assembly.gradPhiFace()),
_test(_var.phiFace()),
_grad_test(_var.gradPhiFace()),
_u(_is_implicit ? _var.sln() : _var.slnOld()),
_grad_u(_is_implicit ? _var.gradSln() : _var.gradSlnOld()),
_save_in_strings(parameters.get<std::vector<AuxVariableName> >("save_in")),
_diag_save_in_strings(parameters.get<std::vector<AuxVariableName> >("diag_save_in"))
{
_save_in.resize(_save_in_strings.size());
_diag_save_in.resize(_diag_save_in_strings.size());
for (unsigned int i=0; i<_save_in_strings.size(); i++)
{
MooseVariable * var = &_subproblem.getVariable(_tid, _save_in_strings[i]);
if (var->feType() != _var.feType())
mooseError("Error in " + _name + ". When saving residual values in an Auxiliary variable the AuxVariable must be the same type as the nonlinear variable the object is acting on.");
_save_in[i] = var;
var->sys().addVariableToZeroOnResidual(_save_in_strings[i]);
addMooseVariableDependency(var);
}
_has_save_in = _save_in.size() > 0;
for (unsigned int i=0; i<_diag_save_in_strings.size(); i++)
{
MooseVariable * var = &_subproblem.getVariable(_tid, _diag_save_in_strings[i]);
if (var->feType() != _var.feType())
mooseError("Error in " + _name + ". When saving diagonal Jacobian values in an Auxiliary variable the AuxVariable must be the same type as the nonlinear variable the object is acting on.");
_diag_save_in[i] = var;
var->sys().addVariableToZeroOnJacobian(_diag_save_in_strings[i]);
addMooseVariableDependency(var);
}
_has_diag_save_in = _diag_save_in.size() > 0;
}
KernelBase::KernelBase(const InputParameters & parameters) :
MooseObject(parameters),
BlockRestrictable(parameters),
SetupInterface(this),
CoupleableMooseVariableDependencyIntermediateInterface(parameters, false),
FunctionInterface(this),
UserObjectInterface(this),
TransientInterface(this),
PostprocessorInterface(this),
MaterialPropertyInterface(this, blockIDs()),
RandomInterface(parameters, *parameters.get<FEProblem *>("_fe_problem"), parameters.get<THREAD_ID>("_tid"), false),
GeometricSearchInterface(this),
Restartable(parameters, "Kernels"),
ZeroInterface(parameters),
MeshChangedInterface(parameters),
_subproblem(*parameters.get<SubProblem *>("_subproblem")),
_fe_problem(*parameters.get<FEProblem *>("_fe_problem")),
_sys(*parameters.get<SystemBase *>("_sys")),
_tid(parameters.get<THREAD_ID>("_tid")),
_assembly(_subproblem.assembly(_tid)),
_var(_sys.getVariable(_tid, parameters.get<NonlinearVariableName>("variable"))),
_mesh(_subproblem.mesh()),
_current_elem(_var.currentElem()),
_current_elem_volume(_assembly.elemVolume()),
_q_point(_assembly.qPoints()),
_qrule(_assembly.qRule()),
_JxW(_assembly.JxW()),
_coord(_assembly.coordTransformation()),
_test(_var.phi()),
_grad_test(_var.gradPhi()),
_phi(_assembly.phi()),
_grad_phi(_assembly.gradPhi()),
_save_in_strings(parameters.get<std::vector<AuxVariableName> >("save_in")),
_diag_save_in_strings(parameters.get<std::vector<AuxVariableName> >("diag_save_in"))
{
_save_in.resize(_save_in_strings.size());
_diag_save_in.resize(_diag_save_in_strings.size());
for (unsigned int i=0; i<_save_in_strings.size(); i++)
{
MooseVariable * var = &_subproblem.getVariable(_tid, _save_in_strings[i]);
if (_fe_problem.getNonlinearSystem().hasVariable(_save_in_strings[i]))
mooseError("Trying to use solution variable "+_save_in_strings[i]+" as a save_in variable in "+name());
if (var->feType() != _var.feType())
mooseError("Error in " + name() + ". When saving residual values in an Auxiliary variable the AuxVariable must be the same type as the nonlinear variable the object is acting on.");
_save_in[i] = var;
var->sys().addVariableToZeroOnResidual(_save_in_strings[i]);
addMooseVariableDependency(var);
}
_has_save_in = _save_in.size() > 0;
for (unsigned int i=0; i<_diag_save_in_strings.size(); i++)
{
MooseVariable * var = &_subproblem.getVariable(_tid, _diag_save_in_strings[i]);
if (_fe_problem.getNonlinearSystem().hasVariable(_diag_save_in_strings[i]))
mooseError("Trying to use solution variable "+_diag_save_in_strings[i]+" as a diag_save_in variable in "+name());
if (var->feType() != _var.feType())
mooseError("Error in " + name() + ". When saving diagonal Jacobian values in an Auxiliary variable the AuxVariable must be the same type as the nonlinear variable the object is acting on.");
_diag_save_in[i] = var;
var->sys().addVariableToZeroOnJacobian(_diag_save_in_strings[i]);
addMooseVariableDependency(var);
}
_has_diag_save_in = _diag_save_in.size() > 0;
}
NodalKernel::NodalKernel(const InputParameters & parameters)
: MooseObject(parameters),
BlockRestrictable(this),
BoundaryRestrictable(this, true), // true for applying to nodesets
SetupInterface(this),
FunctionInterface(this),
UserObjectInterface(this),
TransientInterface(this),
PostprocessorInterface(this),
GeometricSearchInterface(this),
Restartable(this, "BCs"),
MeshChangedInterface(parameters),
RandomInterface(parameters,
*parameters.getCheckedPointerParam<FEProblemBase *>("_fe_problem_base"),
parameters.get<THREAD_ID>("_tid"),
true),
CoupleableMooseVariableDependencyIntermediateInterface(this, true),
MooseVariableInterface<Real>(this,
true,
"variable",
Moose::VarKindType::VAR_NONLINEAR,
Moose::VarFieldType::VAR_FIELD_STANDARD),
TaggingInterface(this),
_subproblem(*getCheckedPointerParam<SubProblem *>("_subproblem")),
_fe_problem(*getCheckedPointerParam<FEProblemBase *>("_fe_problem_base")),
_sys(*getCheckedPointerParam<SystemBase *>("_sys")),
_tid(parameters.get<THREAD_ID>("_tid")),
_assembly(_subproblem.assembly(_tid)),
_var(*mooseVariable()),
_mesh(_subproblem.mesh()),
_current_node(_var.node()),
_u(_var.dofValues()),
_save_in_strings(parameters.get<std::vector<AuxVariableName>>("save_in")),
_diag_save_in_strings(parameters.get<std::vector<AuxVariableName>>("diag_save_in"))
{
_save_in.resize(_save_in_strings.size());
_diag_save_in.resize(_diag_save_in_strings.size());
for (unsigned int i = 0; i < _save_in_strings.size(); i++)
{
MooseVariable * var = &_subproblem.getStandardVariable(_tid, _save_in_strings[i]);
if (var->feType() != _var.feType())
paramError(
"save_in",
"saved-in auxiliary variable is incompatible with the object's nonlinear variable: ",
moose::internal::incompatVarMsg(*var, _var));
_save_in[i] = var;
var->sys().addVariableToZeroOnResidual(_save_in_strings[i]);
addMooseVariableDependency(var);
}
_has_save_in = _save_in.size() > 0;
for (unsigned int i = 0; i < _diag_save_in_strings.size(); i++)
{
MooseVariable * var = &_subproblem.getStandardVariable(_tid, _diag_save_in_strings[i]);
if (var->feType() != _var.feType())
paramError(
"diag_save_in",
"saved-in auxiliary variable is incompatible with the object's nonlinear variable: ",
moose::internal::incompatVarMsg(*var, _var));
_diag_save_in[i] = var;
var->sys().addVariableToZeroOnJacobian(_diag_save_in_strings[i]);
addMooseVariableDependency(var);
}
_has_diag_save_in = _diag_save_in.size() > 0;
}
