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;
}
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;
}
ElementIndicator::ElementIndicator(const std::string & name, InputParameters parameters) :
Indicator(name, parameters),
TransientInterface(parameters, "indicators"),
PostprocessorInterface(parameters),
Coupleable(parameters, false),
ScalarCoupleable(parameters),
MooseVariableInterface(parameters, false),
MaterialPropertyInterface(parameters),
ZeroInterface(parameters),
_field_var(_sys.getVariable(_tid, name)),
_current_elem(_field_var.currentElem()),
_current_elem_volume(_assembly.elemVolume()),
_q_point(_assembly.qPoints()),
_qrule(_assembly.qRule()),
_JxW(_assembly.JxW()),
_coord(_assembly.coordTransformation()),
_var(_subproblem.getVariable(_tid, parameters.get<VariableName>("variable"))),
_u(_var.sln()),
_grad_u(_var.gradSln()),
_u_dot(_var.uDot()),
_du_dot_du(_var.duDotDu())
{
const std::vector<MooseVariable *> & coupled_vars = getCoupledMooseVars();
for (unsigned int i=0; i<coupled_vars.size(); i++)
addMooseVariableDependency(coupled_vars[i]);
addMooseVariableDependency(mooseVariable());
}
ElementIndicator::ElementIndicator(const InputParameters & parameters)
: Indicator(parameters),
TransientInterface(this),
PostprocessorInterface(this),
Coupleable(this, false),
ScalarCoupleable(this),
MooseVariableInterface(this, false),
ZeroInterface(parameters),
_field_var(_sys.getVariable(_tid, name())),
_current_elem(_field_var.currentElem()),
_current_elem_volume(_assembly.elemVolume()),
_q_point(_assembly.qPoints()),
_qrule(_assembly.qRule()),
_JxW(_assembly.JxW()),
_coord(_assembly.coordTransformation()),
_var(_subproblem.getVariable(_tid, parameters.get<VariableName>("variable"))),
_u(_var.sln()),
_grad_u(_var.gradSln()),
_u_dot(_var.uDot()),
_du_dot_du(_var.duDotDu())
{
const std::vector<MooseVariable *> & coupled_vars = getCoupledMooseVars();
for (const auto & var : coupled_vars)
addMooseVariableDependency(var);
addMooseVariableDependency(mooseVariable());
}
SideIntegralVariablePostprocessor::SideIntegralVariablePostprocessor(const std::string & name, InputParameters parameters) :
SideIntegralPostprocessor(name, parameters),
MooseVariableInterface(parameters, false),
_u(coupledValue("variable")),
_grad_u(coupledGradient("variable"))
{
addMooseVariableDependency(mooseVariable());
}
SideIntegralVariablePostprocessor::SideIntegralVariablePostprocessor(
const InputParameters & parameters)
: SideIntegralPostprocessor(parameters),
MooseVariableInterface<Real>(this, false),
_u(coupledValue("variable")),
_grad_u(coupledGradient("variable"))
{
addMooseVariableDependency(mooseVariable());
}
ElementIntegralVariablePostprocessor::ElementIntegralVariablePostprocessor(const InputParameters & parameters) :
ElementIntegralPostprocessor(parameters),
MooseVariableInterface(parameters, false),
_u(coupledValue("variable")),
_grad_u(coupledGradient("variable")),
_u_dot(coupledDot("variable"))
{
addMooseVariableDependency(mooseVariable());
}
ElementVariablePostprocessor::ElementVariablePostprocessor(const std::string & name, InputParameters parameters) :
ElementPostprocessor(name, parameters),
MooseVariableInterface(parameters, false),
_u(coupledValue("variable")),
_grad_u(coupledGradient("variable")),
_u_dot(coupledDot("variable")),
_qp(0)
{
addMooseVariableDependency(mooseVariable());
}
PFCElementEnergyIntegral::PFCElementEnergyIntegral(const InputParameters & parameters) :
ElementIntegralPostprocessor(parameters),
MooseVariableInterface(this, false),
_var(_subproblem.getVariable(_tid, parameters.get<VariableName>("variable"))),
_u(_var.sln()),
_grad_u(_var.gradSln()),
_u_dot(_var.uDot()),
_temp(getParam<Real>("temp")) // K
{
addMooseVariableDependency(mooseVariable());
}
SideIntegralVariableUserObject::SideIntegralVariableUserObject(const InputParameters & parameters)
: SideIntegralUserObject(parameters),
MooseVariableInterface<Real>(this,
false,
"variable",
Moose::VarKindType::VAR_ANY,
Moose::VarFieldType::VAR_FIELD_STANDARD),
_u(coupledValue("variable")),
_grad_u(coupledGradient("variable"))
{
addMooseVariableDependency(mooseVariable());
}
ElementIntegralVariablePostprocessor::ElementIntegralVariablePostprocessor(
const InputParameters & parameters)
: ElementIntegralPostprocessor(parameters),
MooseVariableInterface<Real>(this,
false,
"variable",
Moose::VarKindType::VAR_ANY,
Moose::VarFieldType::VAR_FIELD_STANDARD),
_u(coupledValue("variable")),
_grad_u(coupledGradient("variable"))
{
addMooseVariableDependency(mooseVariable());
}
InternalSideIndicator::InternalSideIndicator(const std::string & name, InputParameters parameters) :
Indicator(name, parameters),
NeighborCoupleable(parameters, false),
ScalarCoupleable(parameters),
NeighborMooseVariableInterface(parameters, false),
TwoMaterialPropertyInterface(parameters),
_field_var(_sys.getVariable(_tid, name)),
_current_elem(_assembly.elem()),
_neighbor_elem(_assembly.neighbor()),
_current_side(_assembly.side()),
_current_side_elem(_assembly.sideElem()),
_coord_sys(_assembly.coordSystem()),
_q_point(_assembly.qPointsFace()),
_qrule(_assembly.qRuleFace()),
_JxW(_assembly.JxWFace()),
_coord(_assembly.coordTransformation()),
_boundary_id(parameters.get<BoundaryID>("_boundary_id")),
_var(_subproblem.getVariable(_tid, parameters.get<VariableName>("variable"))),
_scale_by_flux_faces(parameters.get<bool>("scale_by_flux_faces")),
_u(_var.sln()),
_grad_u(_var.gradSln()),
_normals(_field_var.normals()),
_u_neighbor(_var.slnNeighbor()),
_grad_u_neighbor(_var.gradSlnNeighbor())
{
const std::vector<MooseVariable *> & coupled_vars = getCoupledMooseVars();
for(unsigned int i=0; i<coupled_vars.size(); i++)
addMooseVariableDependency(coupled_vars[i]);
addMooseVariableDependency(mooseVariable());
}
InternalSideIndicator::InternalSideIndicator(const InputParameters & parameters)
: Indicator(parameters),
NeighborCoupleable(this, false, false),
ScalarCoupleable(this),
NeighborMooseVariableInterface(
this, false, Moose::VarKindType::VAR_ANY, Moose::VarFieldType::VAR_FIELD_STANDARD),
_field_var(_sys.getVariable(_tid, name())),
_current_elem(_assembly.elem()),
_neighbor_elem(_assembly.neighbor()),
_current_side(_assembly.side()),
_current_side_elem(_assembly.sideElem()),
_coord_sys(_assembly.coordSystem()),
_q_point(_assembly.qPointsFace()),
_qrule(_assembly.qRuleFace()),
_JxW(_assembly.JxWFace()),
_coord(_assembly.coordTransformation()),
_boundary_id(parameters.get<BoundaryID>("_boundary_id")),
_var(_subproblem.getStandardVariable(_tid, parameters.get<VariableName>("variable"))),
_scale_by_flux_faces(parameters.get<bool>("scale_by_flux_faces")),
_u(_var.sln()),
_grad_u(_var.gradSln()),
_normals(_field_var.normals()),
_u_neighbor(_var.slnNeighbor()),
_grad_u_neighbor(_var.gradSlnNeighbor())
{
const std::vector<MooseVariableFEBase *> & coupled_vars = getCoupledMooseVars();
for (const auto & var : coupled_vars)
addMooseVariableDependency(var);
addMooseVariableDependency(mooseVariable());
}
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;
}
AuxKernel::AuxKernel(const InputParameters & parameters)
: MooseObject(parameters),
MooseVariableInterface<Real>(this,
parameters.getCheckedPointerParam<AuxiliarySystem *>("_aux_sys")
->getVariable(parameters.get<THREAD_ID>("_tid"),
parameters.get<AuxVariableName>("variable"))
.isNodal()),
BlockRestrictable(this),
BoundaryRestrictable(this, mooseVariable()->isNodal()),
SetupInterface(this),
CoupleableMooseVariableDependencyIntermediateInterface(this, mooseVariable()->isNodal()),
FunctionInterface(this),
UserObjectInterface(this),
TransientInterface(this),
MaterialPropertyInterface(this, blockIDs(), boundaryIDs()),
PostprocessorInterface(this),
DependencyResolverInterface(),
RandomInterface(parameters,
*parameters.getCheckedPointerParam<FEProblemBase *>("_fe_problem_base"),
parameters.get<THREAD_ID>("_tid"),
mooseVariable()->isNodal()),
GeometricSearchInterface(this),
Restartable(this, "AuxKernels"),
MeshChangedInterface(parameters),
VectorPostprocessorInterface(this),
_subproblem(*getCheckedPointerParam<SubProblem *>("_subproblem")),
_sys(*getCheckedPointerParam<SystemBase *>("_sys")),
_nl_sys(*getCheckedPointerParam<SystemBase *>("_nl_sys")),
_aux_sys(*getCheckedPointerParam<AuxiliarySystem *>("_aux_sys")),
_tid(parameters.get<THREAD_ID>("_tid")),
_assembly(_subproblem.assembly(_tid)),
_var(_aux_sys.getFieldVariable<Real>(_tid, parameters.get<AuxVariableName>("variable"))),
_nodal(_var.isNodal()),
_bnd(boundaryRestricted()),
_mesh(_subproblem.mesh()),
_q_point(_bnd ? _assembly.qPointsFace() : _assembly.qPoints()),
_qrule(_bnd ? _assembly.qRuleFace() : _assembly.qRule()),
_JxW(_bnd ? _assembly.JxWFace() : _assembly.JxW()),
_coord(_assembly.coordTransformation()),
_u(_nodal ? _var.nodalValue() : _var.sln()),
_u_old(_nodal ? _var.nodalValueOld() : _var.slnOld()),
_u_older(_nodal ? _var.nodalValueOlder() : _var.slnOlder()),
_test(_var.phi()),
_current_elem(_assembly.elem()),
_current_side(_assembly.side()),
_current_elem_volume(_assembly.elemVolume()),
_current_side_volume(_assembly.sideElemVolume()),
_current_node(_assembly.node()),
_solution(_aux_sys.solution())
{
addMooseVariableDependency(mooseVariable());
_supplied_vars.insert(parameters.get<AuxVariableName>("variable"));
std::map<std::string, std::vector<MooseVariableFE *>> coupled_vars = getCoupledVars();
for (const auto & it : coupled_vars)
for (const auto & var : it.second)
_depend_vars.insert(var->name());
}