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;
}
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());
}
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;
}
SideUserObject::SideUserObject(const InputParameters & parameters) :
UserObject(parameters),
BoundaryRestrictable(parameters),
MaterialPropertyInterface(parameters, boundaryIDs()),
Coupleable(parameters, false),
MooseVariableDependencyInterface(),
UserObjectInterface(parameters),
TransientInterface(parameters, "side_user_objects"),
PostprocessorInterface(parameters),
ZeroInterface(parameters),
_mesh(_subproblem.mesh()),
_q_point(_assembly.qPointsFace()),
_qrule(_assembly.qRuleFace()),
_JxW(_assembly.JxWFace()),
_coord(_assembly.coordTransformation()),
_normals(_assembly.normals()),
_current_elem(_assembly.elem()),
_current_side(_assembly.side()),
_current_side_elem(_assembly.sideElem()),
_current_side_volume(_assembly.sideElemVolume())
{
// Keep track of which variables are coupled so we know what we depend on
const std::vector<MooseVariable *> & coupled_vars = getCoupledMooseVars();
for (unsigned int i=0; i<coupled_vars.size(); i++)
addMooseVariableDependency(coupled_vars[i]);
}
ElementUserObject::ElementUserObject(const InputParameters & parameters) :
UserObject(parameters),
BlockRestrictable(parameters),
MaterialPropertyInterface(this, blockIDs()),
UserObjectInterface(this),
Coupleable(this, false),
ScalarCoupleable(this),
MooseVariableDependencyInterface(),
TransientInterface(this),
PostprocessorInterface(this),
RandomInterface(parameters, _fe_problem, _tid, false),
ZeroInterface(parameters),
_mesh(_subproblem.mesh()),
_current_elem(_assembly.elem()),
_current_elem_volume(_assembly.elemVolume()),
_q_point(_assembly.qPoints()),
_qrule(_assembly.qRule()),
_JxW(_assembly.JxW()),
_coord(_assembly.coordTransformation())
{
// Keep track of which variables are coupled so we know what we depend on
const std::vector<MooseVariable *> & coupled_vars = getCoupledMooseVars();
for (const auto & var : coupled_vars)
addMooseVariableDependency(var);
}
FeatureVolumeVectorPostprocessor::FeatureVolumeVectorPostprocessor(
const InputParameters & parameters)
: GeneralVectorPostprocessor(parameters),
MooseVariableDependencyInterface(),
BoundaryRestrictable(this, false),
_single_feature_per_elem(getParam<bool>("single_feature_per_element")),
_output_centroids(getParam<bool>("output_centroids")),
_feature_counter(getUserObject<FeatureFloodCount>("flood_counter")),
_var_num(declareVector("var_num")),
_feature_volumes(declareVector("feature_volumes")),
_intersects_bounds(declareVector("intersects_bounds")),
_percolated(declareVector("percolated")),
_vars(_feature_counter.getFECoupledVars()),
_mesh(_subproblem.mesh()),
_assembly(_subproblem.assembly(_tid)),
_q_point(_assembly.qPoints()),
_qrule(_assembly.qRule()),
_JxW(_assembly.JxW()),
_coord(_assembly.coordTransformation()),
_qrule_face(_assembly.qRuleFace()),
_JxW_face(_assembly.JxWFace())
{
addMooseVariableDependency(_vars);
_is_boundary_restricted = boundaryRestricted();
_coupled_sln.reserve(_vars.size());
for (auto & var : _feature_counter.getCoupledVars())
_coupled_sln.push_back(&var->sln());
}
Marker::Marker(const InputParameters & parameters)
: MooseObject(parameters),
BlockRestrictable(this),
SetupInterface(this),
DependencyResolverInterface(),
UserObjectInterface(this),
Restartable(this, "Markers"),
PostprocessorInterface(this),
MeshChangedInterface(parameters),
OutputInterface(parameters),
_subproblem(*getCheckedPointerParam<SubProblem *>("_subproblem")),
_fe_problem(*getCheckedPointerParam<FEProblemBase *>("_fe_problem_base")),
_adaptivity(_fe_problem.adaptivity()),
_sys(*getCheckedPointerParam<SystemBase *>("_sys")),
_tid(parameters.get<THREAD_ID>("_tid")),
_assembly(_subproblem.assembly(_tid)),
_field_var(_subproblem.getStandardVariable(_tid, name())),
_current_elem(_field_var.currentElem()),
_mesh(_subproblem.mesh())
{
_supplied.insert(name());
addMooseVariableDependency(&_field_var);
}
InterfaceUserObject::InterfaceUserObject(const InputParameters & parameters)
: UserObject(parameters),
BoundaryRestrictableRequired(this, false), // false for applying to sidesets
TwoMaterialPropertyInterface(this, Moose::EMPTY_BLOCK_IDS, boundaryIDs()),
NeighborCoupleable(this, false, false),
MooseVariableDependencyInterface(),
UserObjectInterface(this),
TransientInterface(this),
PostprocessorInterface(this),
_mesh(_subproblem.mesh()),
_q_point(_assembly.qPointsFace()),
_qrule(_assembly.qRuleFace()),
_JxW(_assembly.JxWFace()),
_coord(_assembly.coordTransformation()),
_normals(_assembly.normals()),
_current_elem(_assembly.elem()),
_current_side(_assembly.side()),
_current_side_elem(_assembly.sideElem()),
_current_side_volume(_assembly.sideElemVolume()),
_neighbor_elem(_assembly.neighbor()),
_current_neighbor_volume(_assembly.neighborVolume())
{
// Keep track of which variables are coupled so we know what we depend on
const std::vector<MooseVariableFEBase *> & coupled_vars = getCoupledMooseVars();
for (const auto & var : coupled_vars)
addMooseVariableDependency(var);
}
// DEPRECATED CONSTRUCTOR
ElementUserObject::ElementUserObject(const std::string & deprecated_name, InputParameters parameters) :
UserObject(deprecated_name, parameters),
BlockRestrictable(parameters),
MaterialPropertyInterface(parameters, blockIDs()),
UserObjectInterface(parameters),
Coupleable(parameters, false),
ScalarCoupleable(parameters),
MooseVariableDependencyInterface(),
TransientInterface(parameters, "element_user_objects"),
PostprocessorInterface(parameters),
RandomInterface(parameters, _fe_problem, _tid, false),
ZeroInterface(parameters),
_mesh(_subproblem.mesh()),
_current_elem(_assembly.elem()),
_current_elem_volume(_assembly.elemVolume()),
_q_point(_assembly.qPoints()),
_qrule(_assembly.qRule()),
_JxW(_assembly.JxW()),
_coord(_assembly.coordTransformation())
{
// Keep track of which variables are coupled so we know what we depend on
const std::vector<MooseVariable *> & coupled_vars = getCoupledMooseVars();
for (unsigned int i=0; i<coupled_vars.size(); i++)
addMooseVariableDependency(coupled_vars[i]);
}
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());
}
NodalScalarKernel::NodalScalarKernel(const InputParameters & parameters) :
ScalarKernel(parameters),
Coupleable(parameters, true),
MooseVariableDependencyInterface(),
_node_ids(getParam<std::vector<dof_id_type> >("nodes"))
{
// Fill in the MooseVariable dependencies
const std::vector<MooseVariable *> & coupled_vars = getCoupledMooseVars();
for (unsigned int i=0; i<coupled_vars.size(); i++)
addMooseVariableDependency(coupled_vars[i]);
}
AuxNodalScalarKernel::AuxNodalScalarKernel(const InputParameters & parameters)
: AuxScalarKernel(parameters),
Coupleable(this, true),
MooseVariableDependencyInterface(),
_node_ids(getParam<std::vector<dof_id_type>>("nodes"))
{
// Fill in the MooseVariable dependencies
const std::vector<MooseVariableFEBase *> & coupled_vars = getCoupledMooseVars();
for (const auto & var : coupled_vars)
addMooseVariableDependency(var);
}
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());
}
Material::Material(const InputParameters & parameters)
: MooseObject(parameters),
BlockRestrictable(this),
BoundaryRestrictable(this, blockIDs(), false), // false for being _not_ nodal
SetupInterface(this),
Coupleable(this, false),
MooseVariableDependencyInterface(),
ScalarCoupleable(this),
FunctionInterface(this),
DistributionInterface(this),
UserObjectInterface(this),
TransientInterface(this),
MaterialPropertyInterface(this, blockIDs(), boundaryIDs()),
PostprocessorInterface(this),
VectorPostprocessorInterface(this),
DependencyResolverInterface(),
Restartable(this, "Materials"),
MeshChangedInterface(parameters),
// The false flag disables the automatic call buildOutputVariableHideList;
// for Material objects the hide lists are handled by MaterialOutputAction
OutputInterface(parameters, false),
RandomInterface(parameters,
*parameters.getCheckedPointerParam<FEProblemBase *>("_fe_problem_base"),
parameters.get<THREAD_ID>("_tid"),
false),
_subproblem(*getCheckedPointerParam<SubProblem *>("_subproblem")),
_fe_problem(*getCheckedPointerParam<FEProblemBase *>("_fe_problem_base")),
_tid(parameters.get<THREAD_ID>("_tid")),
_assembly(_subproblem.assembly(_tid)),
_bnd(_material_data_type != Moose::BLOCK_MATERIAL_DATA),
_neighbor(_material_data_type == Moose::NEIGHBOR_MATERIAL_DATA),
_qp(std::numeric_limits<unsigned int>::max()),
_qrule(_bnd ? _assembly.qRuleFace() : _assembly.qRule()),
_JxW(_bnd ? _assembly.JxWFace() : _assembly.JxW()),
_coord(_assembly.coordTransformation()),
_q_point(_bnd ? _assembly.qPointsFace() : _assembly.qPoints()),
_normals(_assembly.normals()),
_current_elem(_neighbor ? _assembly.neighbor() : _assembly.elem()),
_current_subdomain_id(_neighbor ? _assembly.currentNeighborSubdomainID()
: _assembly.currentSubdomainID()),
_current_side(_neighbor ? _assembly.neighborSide() : _assembly.side()),
_mesh(_subproblem.mesh()),
_coord_sys(_assembly.coordSystem()),
_compute(getParam<bool>("compute")),
_constant_option(getParam<MooseEnum>("constant_on").getEnum<ConstantTypeEnum>()),
_has_stateful_property(false)
{
// Fill in the MooseVariable dependencies
const std::vector<MooseVariableFE *> & coupled_vars = getCoupledMooseVars();
for (const auto & var : coupled_vars)
addMooseVariableDependency(var);
}
// DEPRECATED CONSTRUCTOR
QuadraturePointMarker::QuadraturePointMarker(const std::string & deprecated_name, InputParameters parameters) :
Marker(deprecated_name, parameters),
Coupleable(parameters, false),
MaterialPropertyInterface(parameters),
_qrule(_assembly.qRule()),
_q_point(_assembly.qPoints()),
_qp(0)
{
const std::vector<MooseVariable *> & coupled_vars = getCoupledMooseVars();
for (unsigned int i=0; i<coupled_vars.size(); i++)
addMooseVariableDependency(coupled_vars[i]);
}
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;
}
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());
}
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 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());
}
ADNodalBCTempl<T, compute_stage>::ADNodalBCTempl(const InputParameters & parameters)
: NodalBCBase(parameters),
MooseVariableInterface<T>(this,
true,
"variable",
Moose::VarKindType::VAR_NONLINEAR,
std::is_same<T, Real>::value ? Moose::VarFieldType::VAR_FIELD_STANDARD
: Moose::VarFieldType::VAR_FIELD_VECTOR),
_var(*this->mooseVariable()),
_current_node(_var.node()),
_u(_var.template adNodalValue<compute_stage>())
{
addMooseVariableDependency(this->mooseVariable());
}
ProblemElementalL2Error::ProblemElementalL2Error(const InputParameters ¶meters) :
ElementIntegralPostprocessor(parameters),
_cfd_problem(static_cast<CFDProblem&>(_fe_problem)),
_nl(_cfd_problem.getNonlinearSystem()),
_tid(parameters.get<THREAD_ID>("_tid")),
_variables(_nl.getVariableNames()),
_n_equations(_variables.size())
{
for (int eq = 0; eq < _nl.getVariableNames().size(); ++eq)
{
MooseVariable &val = _cfd_problem.getVariable(_tid, _variables[eq]);
_uh.push_back(_is_implicit ? &val.sln() : &val.slnOld());
addMooseVariableDependency(&val);
}
}
Material::Material(const std::string & name, InputParameters parameters) :
MooseObject(name, parameters),
BlockRestrictable(parameters),
BoundaryRestrictable(parameters, blockIDs()),
SetupInterface(parameters),
Coupleable(parameters, false),
MooseVariableDependencyInterface(),
ScalarCoupleable(parameters),
FunctionInterface(parameters),
UserObjectInterface(parameters),
TransientInterface(parameters, "materials"),
MaterialPropertyInterface(parameters, blockIDs(), boundaryIDs()),
PostprocessorInterface(parameters),
DependencyResolverInterface(),
Restartable(parameters, "Materials"),
ZeroInterface(parameters),
MeshChangedInterface(parameters),
// The false flag disables the automatic call buildOutputVariableHideList;
// for Material objects the hide lists are handled by MaterialOutputAction
OutputInterface(parameters, false),
_subproblem(*parameters.get<SubProblem *>("_subproblem")),
_fe_problem(*parameters.get<FEProblem *>("_fe_problem")),
_tid(parameters.get<THREAD_ID>("_tid")),
_assembly(_subproblem.assembly(_tid)),
_bnd(parameters.get<bool>("_bnd")),
_neighbor(getParam<bool>("_neighbor")),
_material_data(*parameters.get<MaterialData *>("_material_data")),
_qp(std::numeric_limits<unsigned int>::max()),
_qrule(_bnd ? _assembly.qRuleFace() : _assembly.qRule()),
_JxW(_bnd ? _assembly.JxWFace() : _assembly.JxW()),
_coord(_assembly.coordTransformation()),
_q_point(_bnd ? _assembly.qPointsFace() : _assembly.qPoints()),
_normals(_assembly.normals()),
_current_elem(_neighbor ? _assembly.neighbor() : _assembly.elem()),
_current_side(_neighbor ? _assembly.neighborSide() : _assembly.side()),
_mesh(_subproblem.mesh()),
_coord_sys(_assembly.coordSystem()),
_has_stateful_property(false)
{
// Fill in the MooseVariable dependencies
const std::vector<MooseVariable *> & coupled_vars = getCoupledMooseVars();
for (unsigned int i=0; i<coupled_vars.size(); i++)
addMooseVariableDependency(coupled_vars[i]);
// Update the MaterialData pointer in BlockRestrictable to use the correct MaterialData object
_blk_material_data = &_material_data;
}
