From b543657c59732a0463c0063924a759ad7ac20635 Mon Sep 17 00:00:00 2001 From: Yaqi Wang Date: Sun, 8 Nov 2020 01:39:15 -0700 Subject: [PATCH] add residual object base class #13609 --- framework/include/base/ResidualObject.h | 122 ++++++++++++++++++ framework/include/bcs/ADIntegratedBC.h | 2 +- framework/include/bcs/ADNodalBC.h | 2 +- framework/include/bcs/ArrayIntegratedBC.h | 2 +- framework/include/bcs/ArrayNodalBC.h | 2 +- framework/include/bcs/BoundaryCondition.h | 65 +--------- framework/include/bcs/IntegratedBC.h | 2 +- framework/include/bcs/IntegratedBCBase.h | 22 ---- framework/include/bcs/NodalBC.h | 2 +- framework/include/bcs/NodalBCBase.h | 9 +- framework/include/bcs/VectorIntegratedBC.h | 2 +- framework/include/bcs/VectorNodalBC.h | 2 +- framework/include/constraints/Constraint.h | 40 +----- .../include/constraints/ElemElemConstraint.h | 7 +- .../constraints/MortarConstraintBase.h | 11 +- .../include/constraints/NodalConstraint.h | 10 +- .../include/constraints/NodeElemConstraint.h | 10 +- .../include/constraints/NodeFaceConstraint.h | 10 +- framework/include/dgkernels/ADDGKernel.h | 2 +- framework/include/dgkernels/ArrayDGKernel.h | 2 +- framework/include/dgkernels/DGKernel.h | 2 +- framework/include/dgkernels/DGKernelBase.h | 50 ++----- framework/include/dirackernels/DiracKernel.h | 54 ++------ .../VectorPostprocessorPointSource.h | 3 +- .../interfacekernels/ADInterfaceKernel.h | 2 +- .../interfacekernels/InterfaceKernel.h | 2 +- .../interfacekernels/InterfaceKernelBase.h | 47 +------ .../include/interfaces/ElementIDInterface.h | 14 +- framework/include/kernels/ADKernel.h | 2 +- framework/include/kernels/ArrayKernel.h | 2 +- framework/include/kernels/Kernel.h | 2 +- framework/include/kernels/KernelBase.h | 100 +------------- framework/include/kernels/ScalarKernel.h | 50 ++----- framework/include/kernels/VectorKernel.h | 2 +- framework/include/nodalkernels/NodalKernel.h | 65 ++-------- framework/include/systems/SystemBase.h | 5 +- .../include/variables/VariableWarehouse.h | 9 +- framework/src/base/ResidualObject.C | 64 +++++++++ framework/src/bcs/BoundaryCondition.C | 29 +---- framework/src/bcs/IntegratedBCBase.C | 4 - framework/src/bcs/NodalBCBase.C | 2 - framework/src/constraints/Constraint.C | 22 +--- .../src/constraints/ConstraintWarehouse.C | 4 +- .../src/constraints/ElemElemConstraint.C | 2 - .../src/constraints/MortarConstraintBase.C | 1 + framework/src/constraints/NodalConstraint.C | 2 - .../src/constraints/NodeElemConstraint.C | 2 - .../src/constraints/NodeFaceConstraint.C | 2 - framework/src/dgkernels/DGKernelBase.C | 25 +--- framework/src/dirackernels/DiracKernel.C | 33 +---- .../VectorPostprocessorPointSource.C | 1 - .../interfacekernels/InterfaceKernelBase.C | 22 +--- framework/src/interfaces/ElementIDInterface.C | 6 +- framework/src/kernels/KernelBase.C | 33 +---- framework/src/kernels/ScalarKernel.C | 49 +------ framework/src/nodalkernels/NodalKernel.C | 41 +----- framework/src/systems/NonlinearEigenSystem.C | 8 +- framework/src/systems/NonlinearSystemBase.C | 8 +- framework/src/systems/SystemBase.C | 4 +- framework/src/variables/VariableWarehouse.C | 6 +- test/tests/restrictable/check_error/tests | 6 +- 61 files changed, 351 insertions(+), 762 deletions(-) create mode 100644 framework/include/base/ResidualObject.h create mode 100644 framework/src/base/ResidualObject.C diff --git a/framework/include/base/ResidualObject.h b/framework/include/base/ResidualObject.h new file mode 100644 index 000000000000..b420d9b71200 --- /dev/null +++ b/framework/include/base/ResidualObject.h @@ -0,0 +1,122 @@ +//* This file is part of the MOOSE framework +//* https://www.mooseframework.org +//* +//* All rights reserved, see COPYRIGHT for full restrictions +//* https://github.com/idaholab/moose/blob/master/COPYRIGHT +//* +//* Licensed under LGPL 2.1, please see LICENSE for details +//* https://www.gnu.org/licenses/lgpl-2.1.html + +#pragma once + +#include "MooseObject.h" +#include "SetupInterface.h" +#include "CoupleableMooseVariableDependencyIntermediateInterface.h" +#include "FunctionInterface.h" +#include "UserObjectInterface.h" +#include "TransientInterface.h" +#include "PostprocessorInterface.h" +#include "VectorPostprocessorInterface.h" +#include "RandomInterface.h" +#include "Restartable.h" +#include "MeshChangedInterface.h" +#include "TaggingInterface.h" + +class MooseMesh; +class SubProblem; +class KernelBase; +class Assembly; +template +class MooseVariableFE; +typedef MooseVariableFE MooseVariable; +typedef MooseVariableFE> VectorMooseVariable; +typedef MooseVariableFE ArrayMooseVariable; + +/** + * This is the common base class for objects that give residual contributions. + */ +class ResidualObject : public MooseObject, + public SetupInterface, + public FunctionInterface, + public UserObjectInterface, + public TransientInterface, + public PostprocessorInterface, + public VectorPostprocessorInterface, + public RandomInterface, + public Restartable, + public MeshChangedInterface, + public TaggingInterface +{ +public: + static InputParameters validParams(); + + /** + * Class constructor. + * @param parameters The InputParameters for the object + * @param nodal Whether this object is applied to nodes or not + */ + ResidualObject(const InputParameters & parameters, bool nodal = false); + + /// Compute this object's contribution to the residual + virtual void computeResidual() = 0; + + /// Compute this object's contribution to the diagonal Jacobian entries + virtual void computeJacobian() = 0; + + /** + * Computes Jacobian block of the variable of this object with respect to a field variable + * @param jvar The field variable + */ + virtual void computeOffDiagJacobian(MooseVariableFEBase & /*jvar*/) {} + + /** + * Computes jacobian block with respect to a scalar variable + * @param jvar The number of the scalar variable + */ + virtual void computeOffDiagJacobianScalar(unsigned int /*jvar*/) {} + + /** + * Compute this object's contribution to the diagonal Jacobian entries + * corresponding to nonlocal dofs of the variable + */ + virtual void computeNonlocalJacobian() {} + + /** + * Computes Jacobian entries corresponding to nonlocal dofs of the jvar + */ + virtual void computeNonlocalOffDiagJacobian(unsigned int /* jvar */) {} + + /** + * Returns the variable that this object operates on. + */ + virtual const MooseVariableBase & variable() const = 0; + + /** + * Returns a reference to the SubProblem for which this Kernel is active + */ + SubProblem & subProblem() { return _subproblem; } + +protected: + virtual void precalculateResidual() {} + virtual void precalculateJacobian() {} + virtual void precalculateOffDiagJacobian(unsigned int /* jvar */) {} + +protected: + /// Reference to this kernel's SubProblem + SubProblem & _subproblem; + + /// Reference to this kernel's FEProblemBase + FEProblemBase & _fe_problem; + + /// Reference to the EquationSystem object + SystemBase & _sys; + + /// The thread ID for this kernel + THREAD_ID _tid; + + /// Reference to this Kernel's assembly object + Assembly & _assembly; + + /// Reference to this Kernel's mesh object + MooseMesh & _mesh; +}; diff --git a/framework/include/bcs/ADIntegratedBC.h b/framework/include/bcs/ADIntegratedBC.h index d276b1f233ba..71ddb58d8261 100644 --- a/framework/include/bcs/ADIntegratedBC.h +++ b/framework/include/bcs/ADIntegratedBC.h @@ -23,7 +23,7 @@ class ADIntegratedBCTempl : public IntegratedBCBase, public MooseVariableInterfa ADIntegratedBCTempl(const InputParameters & parameters); - MooseVariableFE & variable() override { return _var; } + const MooseVariableFE & variable() const override { return _var; } private: void computeJacobian() override final; diff --git a/framework/include/bcs/ADNodalBC.h b/framework/include/bcs/ADNodalBC.h index 3235f3159583..3b4b996e0713 100644 --- a/framework/include/bcs/ADNodalBC.h +++ b/framework/include/bcs/ADNodalBC.h @@ -23,7 +23,7 @@ class ADNodalBCTempl : public NodalBCBase, public MooseVariableInterface ADNodalBCTempl(const InputParameters & parameters); - MooseVariableFE & variable() override { return _var; } + const MooseVariableFE & variable() const override { return _var; } private: void computeResidual() override final; diff --git a/framework/include/bcs/ArrayIntegratedBC.h b/framework/include/bcs/ArrayIntegratedBC.h index 078624b1dbbd..f942d00fc69b 100644 --- a/framework/include/bcs/ArrayIntegratedBC.h +++ b/framework/include/bcs/ArrayIntegratedBC.h @@ -29,7 +29,7 @@ class ArrayIntegratedBC : public IntegratedBCBase, public MooseVariableInterface ArrayIntegratedBC(const InputParameters & parameters); - virtual ArrayMooseVariable & variable() override { return _var; } + virtual const ArrayMooseVariable & variable() const override { return _var; } virtual void computeResidual() override; virtual void computeJacobian() override; diff --git a/framework/include/bcs/ArrayNodalBC.h b/framework/include/bcs/ArrayNodalBC.h index 72eddf2a7907..5a75cf5cd76f 100644 --- a/framework/include/bcs/ArrayNodalBC.h +++ b/framework/include/bcs/ArrayNodalBC.h @@ -32,7 +32,7 @@ class ArrayNodalBC : public NodalBCBase, public MooseVariableInterface -class MooseVariableFE; -typedef MooseVariableFE MooseVariable; -typedef MooseVariableFE> VectorMooseVariable; -class MooseMesh; -class Problem; -class SubProblem; -class SystemBase; class BoundaryCondition; -class Assembly; template <> InputParameters validParams(); @@ -43,19 +24,10 @@ InputParameters validParams(); /** * Base class for creating new types of boundary conditions. */ -class BoundaryCondition : public MooseObject, +class BoundaryCondition : public ResidualObject, public BoundaryRestrictableRequired, - public SetupInterface, - public FunctionInterface, public DistributionInterface, - public UserObjectInterface, - public TransientInterface, - public PostprocessorInterface, - public VectorPostprocessorInterface, - public GeometricSearchInterface, - public Restartable, - public MeshChangedInterface, - public TaggingInterface + public GeometricSearchInterface { public: /** @@ -67,18 +39,6 @@ class BoundaryCondition : public MooseObject, static InputParameters validParams(); - /** - * Get a reference to the MooseVariableFE - * @return Reference to MooseVariableFE - */ - virtual MooseVariableFEBase & variable() = 0; - - /** - * Get a reference to the subproblem - * @return Reference to SubProblem - */ - SubProblem & subProblem() { return _subproblem; } - /** * Hook for turning the boundary condition on and off. * @@ -91,23 +51,4 @@ class BoundaryCondition : public MooseObject, * @return true if the boundary condition should be applied, otherwise false */ virtual bool shouldApply() { return true; } - -protected: - /// Reference to SubProblem - SubProblem & _subproblem; - - /// Reference to FEProblemBase - FEProblemBase & _fe_problem; - - /// Reference to SystemBase - SystemBase & _sys; - - /// Thread id - THREAD_ID _tid; - - /// Reference to assembly - Assembly & _assembly; - - /// Mesh this BC is defined on - MooseMesh & _mesh; }; diff --git a/framework/include/bcs/IntegratedBC.h b/framework/include/bcs/IntegratedBC.h index 5c82a52e300f..53c2a5c77010 100644 --- a/framework/include/bcs/IntegratedBC.h +++ b/framework/include/bcs/IntegratedBC.h @@ -28,7 +28,7 @@ class IntegratedBC : public IntegratedBCBase, public MooseVariableInterface -class MooseVariableFE; -typedef MooseVariableFE MooseVariable; -typedef MooseVariableFE> VectorMooseVariable; template <> InputParameters validParams(); @@ -28,7 +23,6 @@ InputParameters validParams(); * Base class for deriving any boundary condition of a integrated type */ class IntegratedBCBase : public BoundaryCondition, - public RandomInterface, public CoupleableMooseVariableDependencyIntermediateInterface, public MaterialPropertyInterface { @@ -37,10 +31,6 @@ class IntegratedBCBase : public BoundaryCondition, IntegratedBCBase(const InputParameters & parameters); - virtual ~IntegratedBCBase(); - - virtual void computeResidual() = 0; - virtual void computeJacobian() = 0; /** * Computes d-ivar-residual / d-jvar... */ @@ -51,18 +41,6 @@ class IntegratedBCBase : public BoundaryCondition, */ virtual void computeJacobianBlockScalar(unsigned int jvar) = 0; - /** - * Compute this IntegratedBCBase's contribution to the diagonal Jacobian entries - * corresponding to nonlocal dofs of the variable - */ - virtual void computeNonlocalJacobian() {} - - /** - * Computes d-residual / d-jvar... corresponding to nonlocal dofs of the jvar - * and stores the result in nonlocal ke - */ - virtual void computeNonlocalOffDiagJacobian(unsigned int /* jvar */) {} - protected: /// current element const Elem * const & _current_elem; diff --git a/framework/include/bcs/NodalBC.h b/framework/include/bcs/NodalBC.h index 01da43688d99..255fb89cfbca 100644 --- a/framework/include/bcs/NodalBC.h +++ b/framework/include/bcs/NodalBC.h @@ -34,7 +34,7 @@ class NodalBC : public NodalBCBase, public MooseVariableInterface * Gets the variable this BC is active on * @return the variable */ - virtual MooseVariable & variable() override { return _var; } + virtual const MooseVariable & variable() const override { return _var; } virtual void computeResidual() override; virtual void computeJacobian() override; virtual void computeOffDiagJacobian(unsigned int jvar) override; diff --git a/framework/include/bcs/NodalBCBase.h b/framework/include/bcs/NodalBCBase.h index cd9363e10cb1..953db028a6e1 100644 --- a/framework/include/bcs/NodalBCBase.h +++ b/framework/include/bcs/NodalBCBase.h @@ -30,7 +30,6 @@ InputParameters validParams(); * Base class for deriving any boundary condition that works at nodes */ class NodalBCBase : public BoundaryCondition, - public RandomInterface, public CoupleableMooseVariableDependencyIntermediateInterface { public: @@ -38,14 +37,16 @@ class NodalBCBase : public BoundaryCondition, NodalBCBase(const InputParameters & parameters); - virtual void computeResidual() = 0; - virtual void computeJacobian() = 0; + virtual void computeOffDiagJacobian(MooseVariableFEBase & jvar) override + { + computeOffDiagJacobian(jvar.number()); + } virtual void computeOffDiagJacobian(unsigned int jvar) = 0; /** * Compute the off-diagonal contributions from scalar variables */ - virtual void computeOffDiagJacobianScalar(unsigned int /*jvar*/) {} + virtual void computeOffDiagJacobianScalar(unsigned int /*jvar*/) override {} /** * Whether to verify that this object is acting on a nodal variable diff --git a/framework/include/bcs/VectorIntegratedBC.h b/framework/include/bcs/VectorIntegratedBC.h index c16a6af461fa..0d597b45eaab 100644 --- a/framework/include/bcs/VectorIntegratedBC.h +++ b/framework/include/bcs/VectorIntegratedBC.h @@ -28,7 +28,7 @@ class VectorIntegratedBC : public IntegratedBCBase, public MooseVariableInterfac VectorIntegratedBC(const InputParameters & parameters); - virtual VectorMooseVariable & variable() override { return _var; } + virtual const VectorMooseVariable & variable() const override { return _var; } virtual void computeResidual() override; virtual void computeJacobian() override; diff --git a/framework/include/bcs/VectorNodalBC.h b/framework/include/bcs/VectorNodalBC.h index f430fa677213..4590b588a0e4 100644 --- a/framework/include/bcs/VectorNodalBC.h +++ b/framework/include/bcs/VectorNodalBC.h @@ -32,7 +32,7 @@ class VectorNodalBC : public NodalBCBase, public MooseVariableInterface -class MooseVariableFE; -typedef MooseVariableFE MooseVariable; -typedef MooseVariableFE> VectorMooseVariable; -class SubProblem; -class MooseMesh; template <> InputParameters validParams(); @@ -36,27 +22,12 @@ InputParameters validParams(); /** * Base class for all Constraint types */ -class Constraint : public MooseObject, - public SetupInterface, - public FunctionInterface, - public UserObjectInterface, - public TransientInterface, - protected GeometricSearchInterface, - public Restartable, - public MeshChangedInterface, - public TaggingInterface +class Constraint : public ResidualObject, protected GeometricSearchInterface { public: static InputParameters validParams(); Constraint(const InputParameters & parameters); - virtual ~Constraint(); - - /** - * Subproblem this constraint is part of - * @return The reference to the subproblem - */ - SubProblem & subProblem() { return _subproblem; } virtual bool addCouplingEntriesToJacobian() { return true; } virtual void subdomainSetup() override final @@ -67,13 +38,6 @@ class Constraint : public MooseObject, virtual void residualEnd() {} protected: - SystemBase & _sys; - - THREAD_ID _tid; - - Assembly & _assembly; - MooseMesh & _mesh; - unsigned int _i, _j; unsigned int _qp; }; diff --git a/framework/include/constraints/ElemElemConstraint.h b/framework/include/constraints/ElemElemConstraint.h index 4e75539a6d2a..f4bcdbae39f8 100644 --- a/framework/include/constraints/ElemElemConstraint.h +++ b/framework/include/constraints/ElemElemConstraint.h @@ -48,7 +48,7 @@ class ElemElemConstraint : public Constraint, /** * Computes the residual for the current side. */ - virtual void computeResidual(); + virtual void computeResidual() override; /** * Computes the element/neighbor-element/neighbor Jacobian @@ -58,7 +58,7 @@ class ElemElemConstraint : public Constraint, /** * Computes the jacobian for the current side. */ - virtual void computeJacobian(); + virtual void computeJacobian() override; /** * Get the interface ID @@ -68,7 +68,7 @@ class ElemElemConstraint : public Constraint, /** * The variable number that this object operates on. */ - MooseVariable & variable() { return _var; } + const MooseVariable & variable() const override { return _var; } protected: FEProblemBase & _fe_problem; @@ -133,4 +133,3 @@ class ElemElemConstraint : public Constraint, */ virtual Real computeQpJacobian(Moose::DGJacobianType type) = 0; }; - diff --git a/framework/include/constraints/MortarConstraintBase.h b/framework/include/constraints/MortarConstraintBase.h index c98a121c21c0..abb7908b8a67 100644 --- a/framework/include/constraints/MortarConstraintBase.h +++ b/framework/include/constraints/MortarConstraintBase.h @@ -50,6 +50,15 @@ class MortarConstraintBase : public Constraint, MortarConstraintBase(const InputParameters & parameters); + virtual void computeResidual() override final + { + mooseError("MortarConstraintBase do not need computeResidual()"); + } + virtual void computeJacobian() override final + { + mooseError("MortarConstraintBase do not need computeJacobian()"); + } + /** * Method for computing the residual * @param has_primary Whether the mortar segment element projects onto the primary face @@ -75,7 +84,7 @@ class MortarConstraintBase : public Constraint, /** * The variable number that this object operates on. */ - const MooseVariable * variable() const { return _var; } + const MooseVariable & variable() const override { return *_var; } /** * Whether to use dual mortar diff --git a/framework/include/constraints/NodalConstraint.h b/framework/include/constraints/NodalConstraint.h index 19d5e564f84c..00e2ce210efb 100644 --- a/framework/include/constraints/NodalConstraint.h +++ b/framework/include/constraints/NodalConstraint.h @@ -72,17 +72,25 @@ class NodalConstraint : public Constraint, /** * Computes the nodal residual. */ + virtual void computeResidual() override final + { + mooseError("NodalConstraint do not need computeResidual()"); + } virtual void computeResidual(NumericVector & residual); /** * Computes the jacobian for the current element. */ + virtual void computeJacobian() override final + { + mooseError("NodalConstraint do not need computeJacobian()"); + } virtual void computeJacobian(SparseMatrix & jacobian); /** * The variable number that this object operates on. */ - MooseVariable & variable() { return _var; } + const MooseVariable & variable() const override { return _var; } protected: /** diff --git a/framework/include/constraints/NodeElemConstraint.h b/framework/include/constraints/NodeElemConstraint.h index a625c9e310fd..657d41e9b035 100644 --- a/framework/include/constraints/NodeElemConstraint.h +++ b/framework/include/constraints/NodeElemConstraint.h @@ -45,12 +45,16 @@ class NodeElemConstraint : public Constraint, void computeSecondaryValue(NumericVector & current_solution); /// Computes the residual Nodal residual. - virtual void computeResidual(); + virtual void computeResidual() override; /// Computes the jacobian for the current element. - virtual void computeJacobian(); + virtual void computeJacobian() override; /// Computes d-residual / d-jvar... + virtual void computeOffDiagJacobian(MooseVariableFEBase & jvar) override + { + computeOffDiagJacobian(jvar.number()); + } virtual void computeOffDiagJacobian(unsigned int jvar); /// Gets the indices for all dofs connected to the constraint @@ -85,7 +89,7 @@ class NodeElemConstraint : public Constraint, /** * The variable number that this object operates on. */ - MooseVariable & variable() { return _var; } + const MooseVariable & variable() const override { return _var; } protected: /// prepare the _secondary_to_primary_map diff --git a/framework/include/constraints/NodeFaceConstraint.h b/framework/include/constraints/NodeFaceConstraint.h index 652193dba569..d4be3b150a14 100644 --- a/framework/include/constraints/NodeFaceConstraint.h +++ b/framework/include/constraints/NodeFaceConstraint.h @@ -53,16 +53,20 @@ class NodeFaceConstraint : public Constraint, /** * Computes the residual Nodal residual. */ - virtual void computeResidual(); + virtual void computeResidual() override; /** * Computes the jacobian for the current element. */ - virtual void computeJacobian(); + virtual void computeJacobian() override; /** * Computes d-residual / d-jvar... */ + virtual void computeOffDiagJacobian(MooseVariableFEBase & jvar) override + { + computeOffDiagJacobian(jvar.number()); + } virtual void computeOffDiagJacobian(unsigned int jvar); /** @@ -101,7 +105,7 @@ class NodeFaceConstraint : public Constraint, /** * The variable number that this object operates on. */ - MooseVariable & variable() { return _var; } + const MooseVariable & variable() const override { return _var; } // TODO: Make this protected or add an accessor // Do the same for all the other public members diff --git a/framework/include/dgkernels/ADDGKernel.h b/framework/include/dgkernels/ADDGKernel.h index 8cb9453a2b9c..84910ac2b5fb 100644 --- a/framework/include/dgkernels/ADDGKernel.h +++ b/framework/include/dgkernels/ADDGKernel.h @@ -29,7 +29,7 @@ class ADDGKernel : public DGKernelBase, public NeighborMooseVariableInterface(); /** * Serves as a base class for DGKernel and ADDGKernel */ -class DGKernelBase : public MooseObject, +class DGKernelBase : public ResidualObject, public BlockRestrictable, public BoundaryRestrictable, - public SetupInterface, - public TransientInterface, - public FunctionInterface, - public UserObjectInterface, public NeighborCoupleableMooseVariableDependencyIntermediateInterface, public TwoMaterialPropertyInterface, - public Restartable, - public MeshChangedInterface, - public TaggingInterface, public ElementIDInterface { public: @@ -69,18 +52,6 @@ class DGKernelBase : public MooseObject, DGKernelBase(const InputParameters & parameters); - virtual ~DGKernelBase(); - - /** - * The variable this kernel operating on. - */ - virtual MooseVariableFEBase & variable() = 0; - - /** - * Return a reference to the subproblem. - */ - SubProblem & subProblem() { return _subproblem; } - /** * Computes the residual for this element or the neighbor */ @@ -89,7 +60,7 @@ class DGKernelBase : public MooseObject, /** * Computes the residual for the current side. */ - virtual void computeResidual(); + virtual void computeResidual() override; /** * Computes the element/neighbor-element/neighbor Jacobian @@ -99,7 +70,7 @@ class DGKernelBase : public MooseObject, /** * Computes the jacobian for the current side. */ - virtual void computeJacobian(); + virtual void computeJacobian() override; /** * Computes the element-element off-diagonal Jacobian @@ -109,17 +80,14 @@ class DGKernelBase : public MooseObject, /** * Computes d-residual / d-jvar... */ + virtual void computeOffDiagJacobian(MooseVariableFEBase & jvar) override + { + computeOffDiagJacobian(jvar.number()); + } virtual void computeOffDiagJacobian(unsigned int jvar); protected: - SubProblem & _subproblem; - SystemBase & _sys; - - THREAD_ID _tid; - - Assembly & _assembly; - MooseMesh & _mesh; - + /// Current element const Elem * const & _current_elem; /// The volume (or length) of the current element diff --git a/framework/include/dirackernels/DiracKernel.h b/framework/include/dirackernels/DiracKernel.h index bb42c60a6b47..28837eca7313 100644 --- a/framework/include/dirackernels/DiracKernel.h +++ b/framework/include/dirackernels/DiracKernel.h @@ -11,26 +11,15 @@ // MOOSE includes #include "DiracKernelInfo.h" -#include "MooseObject.h" -#include "SetupInterface.h" +#include "ResidualObject.h" #include "CoupleableMooseVariableDependencyIntermediateInterface.h" -#include "FunctionInterface.h" -#include "UserObjectInterface.h" #include "MaterialPropertyInterface.h" -#include "TransientInterface.h" -#include "PostprocessorInterface.h" #include "GeometricSearchInterface.h" #include "MooseVariableField.h" -#include "Restartable.h" -#include "MeshChangedInterface.h" #include "MooseVariableInterface.h" -#include "TaggingInterface.h" // Forward Declarations -class Assembly; class DiracKernel; -class SubProblem; -class MooseMesh; template <> InputParameters validParams(); @@ -42,35 +31,26 @@ InputParameters validParams(); * * This is common in point sources / sinks and various other algorithms. */ -class DiracKernel : public MooseObject, - public SetupInterface, +class DiracKernel : public ResidualObject, public CoupleableMooseVariableDependencyIntermediateInterface, public MooseVariableInterface, - public FunctionInterface, - public UserObjectInterface, - public TransientInterface, public MaterialPropertyInterface, - public PostprocessorInterface, - protected GeometricSearchInterface, - public Restartable, - public MeshChangedInterface, - public TaggingInterface + protected GeometricSearchInterface { public: static InputParameters validParams(); DiracKernel(const InputParameters & parameters); - virtual ~DiracKernel() {} /** * Computes the residual for the current element. */ - virtual void computeResidual(); + virtual void computeResidual() override; /** * Computes the jacobian for the current element. */ - virtual void computeJacobian(); + virtual void computeJacobian() override; /** * This gets called by computeOffDiagJacobian() at each quadrature point. @@ -80,17 +60,13 @@ class DiracKernel : public MooseObject, /** * Computes the off-diagonal Jacobian for variable jvar. */ + virtual void computeOffDiagJacobian(MooseVariableFEBase & jvar) override + { + computeOffDiagJacobian(jvar.number()); + } virtual void computeOffDiagJacobian(unsigned int jvar); - /** - * The variable number that this kernel operates on. - */ - MooseVariableField & variable(); - - /** - * Return a reference to the subproblem. - */ - SubProblem & subProblem(); + virtual const MooseVariableField & variable() const override { return _var; } /** * This is where the DiracKernel should call addPoint() for each point it needs to have a @@ -153,19 +129,9 @@ class DiracKernel : public MooseObject, */ unsigned currentPointCachedID(); - SubProblem & _subproblem; - SystemBase & _sys; - - THREAD_ID _tid; - - Assembly & _assembly; - /// Variable this kernel acts on MooseVariableField & _var; - /// Mesh this kernels acts on - MooseMesh & _mesh; - /// Coordinate system const Moose::CoordinateSystemType & _coord_sys; diff --git a/framework/include/dirackernels/VectorPostprocessorPointSource.h b/framework/include/dirackernels/VectorPostprocessorPointSource.h index 580615bfe1fd..ac21bc475e13 100644 --- a/framework/include/dirackernels/VectorPostprocessorPointSource.h +++ b/framework/include/dirackernels/VectorPostprocessorPointSource.h @@ -11,7 +11,6 @@ // Moose Includes #include "DiracKernel.h" -#include "VectorPostprocessorInterface.h" // Forward Declarations class VectorPostprocessorPointSource; @@ -24,7 +23,7 @@ InputParameters validParams(); * Coordinates and values are given by a vector Postprocessor. Values and coordinates for the point * source are allowed change as the vector Postprocessor is updated. */ -class VectorPostprocessorPointSource : public DiracKernel, public VectorPostprocessorInterface +class VectorPostprocessorPointSource : public DiracKernel { public: static InputParameters validParams(); diff --git a/framework/include/interfacekernels/ADInterfaceKernel.h b/framework/include/interfacekernels/ADInterfaceKernel.h index b42efa8afaad..b3b4dabb12df 100644 --- a/framework/include/interfacekernels/ADInterfaceKernel.h +++ b/framework/include/interfacekernels/ADInterfaceKernel.h @@ -25,7 +25,7 @@ class ADInterfaceKernelTempl : public InterfaceKernelBase, public NeighborMooseV ADInterfaceKernelTempl(const InputParameters & parameters); /// The primary variable that this interface kernel operates on - MooseVariableFE & variable() const override { return _var; } + const MooseVariableFE & variable() const override { return _var; } /// The neighbor variable number that this interface kernel operates on const MooseVariableFE & neighborVariable() const override { return _neighbor_var; } diff --git a/framework/include/interfacekernels/InterfaceKernel.h b/framework/include/interfacekernels/InterfaceKernel.h index 9270bfa82263..b70cd51c33d4 100644 --- a/framework/include/interfacekernels/InterfaceKernel.h +++ b/framework/include/interfacekernels/InterfaceKernel.h @@ -45,7 +45,7 @@ class InterfaceKernelTempl : public InterfaceKernelBase, public NeighborMooseVar InterfaceKernelTempl(const InputParameters & parameters); /// The primary variable that this interface kernel operates on - virtual MooseVariableFE & variable() const override { return _var; } + virtual const MooseVariableFE & variable() const override { return _var; } /// The neighbor variable number that this interface kernel operates on virtual const MooseVariableFE & neighborVariable() const override { return _neighbor_var; } diff --git a/framework/include/interfacekernels/InterfaceKernelBase.h b/framework/include/interfacekernels/InterfaceKernelBase.h index ca5abc4f00d7..5406dc77731d 100644 --- a/framework/include/interfacekernels/InterfaceKernelBase.h +++ b/framework/include/interfacekernels/InterfaceKernelBase.h @@ -11,18 +11,10 @@ // local includes #include "MooseArray.h" -#include "MooseObject.h" +#include "ResidualObject.h" #include "BoundaryRestrictable.h" -#include "SetupInterface.h" -#include "TransientInterface.h" -#include "UserObjectInterface.h" -#include "PostprocessorInterface.h" #include "NeighborCoupleableMooseVariableDependencyIntermediateInterface.h" -#include "FunctionInterface.h" -#include "Restartable.h" -#include "MeshChangedInterface.h" #include "TwoMaterialPropertyInterface.h" -#include "TaggingInterface.h" #include "ElementIDInterface.h" // Forward Declarations @@ -35,18 +27,10 @@ InputParameters validParams(); * InterfaceKernelBase is the base class for all InterfaceKernel type classes. */ -class InterfaceKernelBase : public MooseObject, +class InterfaceKernelBase : public ResidualObject, public BoundaryRestrictable, - public SetupInterface, - public TransientInterface, - public FunctionInterface, - public UserObjectInterface, - public PostprocessorInterface, public NeighborCoupleableMooseVariableDependencyIntermediateInterface, - public Restartable, - public MeshChangedInterface, public TwoMaterialPropertyInterface, - public TaggingInterface, public ElementIDInterface { public: @@ -54,15 +38,9 @@ class InterfaceKernelBase : public MooseObject, InterfaceKernelBase(const InputParameters & parameters); - /// The primary variable that this interface kernel operates on - virtual MooseVariableFEBase & variable() const = 0; - /// The neighbor variable number that this interface kernel operates on virtual const MooseVariableFEBase & neighborVariable() const = 0; - /// Return a reference to the subproblem. - SubProblem & subProblem() { return _subproblem; } - /** * Using the passed DGResidual type, selects the correct test function space and residual block, * and then calls computeQpResidual @@ -89,12 +67,6 @@ class InterfaceKernelBase : public MooseObject, /// Selects the correct Jacobian type and routine to call for the secondary variable jacobian virtual void computeNeighborOffDiagJacobian(unsigned int jvar) = 0; - /// Computes the residual for the current side. - virtual void computeResidual() = 0; - - /// Computes the jacobian for the current side. - virtual void computeJacobian() = 0; - protected: /// Compute jacobians at quadrature points virtual Real computeQpJacobian(Moose::DGJacobianType /*type*/) { return 0; } @@ -108,21 +80,6 @@ class InterfaceKernelBase : public MooseObject, /// The volume of the current neighbor const Real & getNeighborElemVolume(); - /// Reference to the controlling finite element problem - SubProblem & _subproblem; - - /// Reference to the nonlinear system - SystemBase & _sys; - - /// The thread ID - THREAD_ID _tid; - - /// Problem assembly - Assembly & _assembly; - - /// The problem mesh - MooseMesh & _mesh; - /// Pointer reference to the current element const Elem * const & _current_elem; diff --git a/framework/include/interfaces/ElementIDInterface.h b/framework/include/interfaces/ElementIDInterface.h index b016bbd3c720..43fea86d04b8 100644 --- a/framework/include/interfaces/ElementIDInterface.h +++ b/framework/include/interfaces/ElementIDInterface.h @@ -77,14 +77,14 @@ class ElementIDInterface /** * Whether mesh has an element integer with a given name */ - bool hasElementID(const std::string & id_name) const { return _mesh->hasElementID(id_name); } + bool hasElementID(const std::string & id_name) const { return _id_mesh->hasElementID(id_name); } /** * Return the maximum element ID for an element integer with its index */ dof_id_type maxElementID(unsigned int elem_id_index) const { - return _mesh->maxElementID(elem_id_index); + return _id_mesh->maxElementID(elem_id_index); } /** @@ -92,7 +92,7 @@ class ElementIDInterface */ dof_id_type minElementID(unsigned int elem_id_index) const { - return _mesh->minElementID(elem_id_index); + return _id_mesh->minElementID(elem_id_index); } /** @@ -100,7 +100,7 @@ class ElementIDInterface */ bool areElemIDsIdentical(const std::string & id_name1, const std::string & id_name2) const { - return _mesh->areElemIDsIdentical(id_name1, id_name2); + return _id_mesh->areElemIDsIdentical(id_name1, id_name2); } /** @@ -108,7 +108,7 @@ class ElementIDInterface */ std::set getAllElemIDs(unsigned int elem_id_index) const { - return _mesh->getAllElemIDs(elem_id_index); + return _id_mesh->getAllElemIDs(elem_id_index); } /** @@ -118,7 +118,7 @@ class ElementIDInterface std::set getElemIDsOnBlocks(unsigned int elem_id_index, const std::set & blks) const { - return _mesh->getElemIDsOnBlocks(elem_id_index, blks); + return _id_mesh->getElemIDsOnBlocks(elem_id_index, blks); } /** @@ -137,5 +137,5 @@ class ElementIDInterface const InputParameters & _obj_parameters; /// References to the mesh and displaced mesh (currently in the ActionWarehouse) - std::shared_ptr & _mesh; + std::shared_ptr & _id_mesh; }; diff --git a/framework/include/kernels/ADKernel.h b/framework/include/kernels/ADKernel.h index 7ca77cc762f1..9d1332c1ec1a 100644 --- a/framework/include/kernels/ADKernel.h +++ b/framework/include/kernels/ADKernel.h @@ -30,7 +30,7 @@ class ADKernelTempl : public KernelBase, public MooseVariableInterface void jacobianSetup() override; - MooseVariableFE & variable() override { return _var; } + const MooseVariableFE & variable() const override { return _var; } private: void computeJacobian() override final; diff --git a/framework/include/kernels/ArrayKernel.h b/framework/include/kernels/ArrayKernel.h index 742c7b83b8cb..416b1ced3592 100644 --- a/framework/include/kernels/ArrayKernel.h +++ b/framework/include/kernels/ArrayKernel.h @@ -40,7 +40,7 @@ class ArrayKernel : public KernelBase, public MooseVariableInterface */ virtual void computeOffDiagJacobianScalar(unsigned int jvar) override; - virtual MooseVariable & variable() override { return _var; } + virtual const MooseVariable & variable() const override { return _var; } protected: /** diff --git a/framework/include/kernels/KernelBase.h b/framework/include/kernels/KernelBase.h index a593202eff5d..fe1c4db08880 100644 --- a/framework/include/kernels/KernelBase.h +++ b/framework/include/kernels/KernelBase.h @@ -9,32 +9,12 @@ #pragma once -#include "MooseObject.h" +#include "ResidualObject.h" #include "BlockRestrictable.h" -#include "SetupInterface.h" -#include "CoupleableMooseVariableDependencyIntermediateInterface.h" -#include "FunctionInterface.h" -#include "UserObjectInterface.h" -#include "TransientInterface.h" -#include "PostprocessorInterface.h" -#include "VectorPostprocessorInterface.h" #include "MaterialPropertyInterface.h" -#include "RandomInterface.h" #include "GeometricSearchInterface.h" -#include "Restartable.h" -#include "MeshChangedInterface.h" -#include "TaggingInterface.h" #include "ElementIDInterface.h" -class MooseMesh; -class SubProblem; -class KernelBase; -class Assembly; -template -class MooseVariableFE; -typedef MooseVariableFE MooseVariable; -typedef MooseVariableFE> VectorMooseVariable; - template <> InputParameters validParams(); @@ -42,21 +22,11 @@ InputParameters validParams(); * This is the common base class for the three main * kernel types implemented in MOOSE, Kernel, VectorKernel and ArrayKernel. */ -class KernelBase : public MooseObject, +class KernelBase : public ResidualObject, public BlockRestrictable, - public SetupInterface, public CoupleableMooseVariableDependencyIntermediateInterface, - public FunctionInterface, - public UserObjectInterface, - public TransientInterface, - public PostprocessorInterface, - public VectorPostprocessorInterface, public MaterialPropertyInterface, - public RandomInterface, protected GeometricSearchInterface, - public Restartable, - public MeshChangedInterface, - public TaggingInterface, public ElementIDInterface { public: @@ -64,72 +34,8 @@ class KernelBase : public MooseObject, KernelBase(const InputParameters & parameters); - virtual ~KernelBase(); - - /// Compute this Kernel's contribution to the residual - virtual void computeResidual() = 0; - - /// Compute this Kernel's contribution to the diagonal Jacobian entries - virtual void computeJacobian() = 0; - - /// Computes d-residual / d-jvar... storing the result in Ke. - virtual void computeOffDiagJacobian(MooseVariableFEBase & jvar) = 0; - - /** - * Computes jacobian block with respect to a scalar variable - * @param jvar The number of the scalar variable - */ - virtual void computeOffDiagJacobianScalar(unsigned int jvar) = 0; - - /** - * Compute this Kernel's contribution to the diagonal Jacobian entries - * corresponding to nonlocal dofs of the variable - */ - virtual void computeNonlocalJacobian() {} - - /** - * Computes d-residual / d-jvar... corresponding to nonlocal dofs of the jvar - * and stores the result in nonlocal ke - */ - virtual void computeNonlocalOffDiagJacobian(unsigned int /* jvar */) {} - - /** - * Returns the variable that this Kernel operates on. - */ - virtual MooseVariableFEBase & variable() = 0; - - /** - * Returns a reference to the SubProblem for which this Kernel is active - */ - SubProblem & subProblem() { return _subproblem; } - -protected: - /** - * Following methods are used for Kernels that need to perform a per-element calculation - */ - virtual void precalculateResidual() {} - virtual void precalculateJacobian() {} - virtual void precalculateOffDiagJacobian(unsigned int /* jvar */) {} - protected: - /// Reference to this kernel's SubProblem - SubProblem & _subproblem; - - /// Reference to this kernel's FEProblemBase - FEProblemBase & _fe_problem; - - /// Reference to the EquationSystem object - SystemBase & _sys; - - /// The thread ID for this kernel - THREAD_ID _tid; - - /// Reference to this Kernel's assembly object - Assembly & _assembly; - - /// Reference to this Kernel's mesh object - MooseMesh & _mesh; - + /// Current element const Elem * const & _current_elem; /// Volume of the current element diff --git a/framework/include/kernels/ScalarKernel.h b/framework/include/kernels/ScalarKernel.h index 9cadb547e745..d52b21774d3b 100644 --- a/framework/include/kernels/ScalarKernel.h +++ b/framework/include/kernels/ScalarKernel.h @@ -9,39 +9,17 @@ #pragma once -#include "MooseObject.h" +#include "ResidualObject.h" #include "ScalarCoupleable.h" -#include "SetupInterface.h" -#include "FunctionInterface.h" -#include "UserObjectInterface.h" -#include "PostprocessorInterface.h" -#include "TransientInterface.h" -#include "MeshChangedInterface.h" -#include "VectorPostprocessorInterface.h" -#include "TaggingInterface.h" +#include "MooseVariableScalar.h" // Forward declarations class ScalarKernel; -class MooseMesh; -class Problem; -class SubProblem; -class Assembly; -class MooseVariableScalar; -class SubProblem; template <> InputParameters validParams(); -class ScalarKernel : public MooseObject, - public ScalarCoupleable, - public SetupInterface, - public FunctionInterface, - public UserObjectInterface, - public PostprocessorInterface, - public TransientInterface, - public MeshChangedInterface, - protected VectorPostprocessorInterface, - public TaggingInterface +class ScalarKernel : public ResidualObject, public ScalarCoupleable { public: static InputParameters validParams(); @@ -49,33 +27,26 @@ class ScalarKernel : public MooseObject, ScalarKernel(const InputParameters & parameters); virtual void reinit() = 0; - virtual void computeResidual() = 0; - virtual void computeJacobian() = 0; - virtual void computeOffDiagJacobian(unsigned int jvar); + virtual void computeOffDiagJacobian(MooseVariableFEBase & jvar) override + { + computeOffDiagJacobian(jvar.number()); + } + virtual void computeOffDiagJacobian(unsigned int /*jvar*/) {} /** * The variable that this kernel operates on. */ - MooseVariableScalar & variable(); - - SubProblem & subProblem(); + virtual const MooseVariableScalar & variable() const override { return _var; } /** * Use this to enable/disable the constraint * @return true if the constrain is active */ - virtual bool isActive(); + virtual bool isActive() { return true; } protected: - SubProblem & _subproblem; - SystemBase & _sys; - - THREAD_ID _tid; - - Assembly & _assembly; /// Scalar variable MooseVariableScalar & _var; - MooseMesh & _mesh; unsigned int _i, _j; @@ -85,4 +56,3 @@ class ScalarKernel : public MooseObject, /// Old value(s) of the scalar variable VariableValue & _u_old; }; - diff --git a/framework/include/kernels/VectorKernel.h b/framework/include/kernels/VectorKernel.h index 777e5d16560d..94d969edb25b 100644 --- a/framework/include/kernels/VectorKernel.h +++ b/framework/include/kernels/VectorKernel.h @@ -39,7 +39,7 @@ class VectorKernel : public KernelBase, public MooseVariableInterface -class MooseVariableFE; -typedef MooseVariableFE MooseVariable; -typedef MooseVariableFE> VectorMooseVariable; -class MooseMesh; -class SubProblem; -class SystemBase; class NodalKernel; -class Assembly; template <> InputParameters validParams(); @@ -45,21 +27,12 @@ InputParameters validParams(); * Base class for creating new types of boundary conditions * */ -class NodalKernel : public MooseObject, +class NodalKernel : public ResidualObject, public BlockRestrictable, public BoundaryRestrictable, - public SetupInterface, - public FunctionInterface, - public UserObjectInterface, - public TransientInterface, - public PostprocessorInterface, public GeometricSearchInterface, - public Restartable, - public MeshChangedInterface, - public RandomInterface, public CoupleableMooseVariableDependencyIntermediateInterface, - public MooseVariableInterface, - public TaggingInterface + public MooseVariableInterface { public: /** @@ -74,13 +47,7 @@ class NodalKernel : public MooseObject, * Gets the variable this is active on * @return the variable */ - MooseVariable & variable(); - - /** - * Get a reference to the subproblem - * @return Reference to SubProblem - */ - SubProblem & subProblem(); + const MooseVariable & variable() const override { return _var; } /** * Compute the residual at the current node. @@ -88,7 +55,7 @@ class NodalKernel : public MooseObject, * Note: This is NOT what a user would normally want to override. * Usually a user would override computeQpResidual() */ - virtual void computeResidual(); + virtual void computeResidual() override; /** * Compute the Jacobian at one node. @@ -96,7 +63,7 @@ class NodalKernel : public MooseObject, * Note: This is NOT what a user would normally want to override. * Usually a user would override computeQpJacobian() */ - virtual void computeJacobian(); + virtual void computeJacobian() override; /** * Compute the off-diagonal Jacobian at one node. @@ -104,6 +71,10 @@ class NodalKernel : public MooseObject, * Note: This is NOT what a user would normally want to override. * Usually a user would override computeQpOffDiagJacobian() */ + virtual void computeOffDiagJacobian(MooseVariableFEBase & jvar) override + { + computeOffDiagJacobian(jvar.number()); + } virtual void computeOffDiagJacobian(unsigned int jvar); protected: @@ -125,27 +96,12 @@ class NodalKernel : public MooseObject, */ virtual Real computeQpOffDiagJacobian(unsigned int jvar); - /// Reference to SubProblem - SubProblem & _subproblem; - /// Reference to FEProblemBase FEProblemBase & _fe_problem; - /// Reference to SystemBase - SystemBase & _sys; - - /// Thread id - THREAD_ID _tid; - - /// Reference to assembly - Assembly & _assembly; - /// variable this works on MooseVariable & _var; - /// Mesh this is defined on - MooseMesh & _mesh; - /// current node being processed const Node * const & _current_node; @@ -165,4 +121,3 @@ class NodalKernel : public MooseObject, std::vector _diag_save_in; std::vector _diag_save_in_strings; }; - diff --git a/framework/include/systems/SystemBase.h b/framework/include/systems/SystemBase.h index 605429bf2ff2..37cb3c291765 100644 --- a/framework/include/systems/SystemBase.h +++ b/framework/include/systems/SystemBase.h @@ -529,7 +529,8 @@ class SystemBase : public libMesh::ParallelObject, public ConsoleStreamInterface * @param var_name A string which is the name of the variable to get. * @return reference the variable (class) */ - virtual MooseVariableScalar & getScalarVariable(THREAD_ID tid, const std::string & var_name); + virtual MooseVariableScalar & getScalarVariable(THREAD_ID tid, + const std::string & var_name) const; /** * Gets a reference to a variable with specified number @@ -538,7 +539,7 @@ class SystemBase : public libMesh::ParallelObject, public ConsoleStreamInterface * @param var_number libMesh variable number * @return reference the variable (class) */ - virtual MooseVariableScalar & getScalarVariable(THREAD_ID tid, unsigned int var_number); + virtual MooseVariableScalar & getScalarVariable(THREAD_ID tid, unsigned int var_number) const; /** * Get the block where a variable of this system is defined diff --git a/framework/include/variables/VariableWarehouse.h b/framework/include/variables/VariableWarehouse.h index 3b84724c3c58..9bd3e001025b 100644 --- a/framework/include/variables/VariableWarehouse.h +++ b/framework/include/variables/VariableWarehouse.h @@ -59,14 +59,15 @@ class VariableWarehouse * @param bnd The boundary id where this variable is defined * @param var The variable */ - void addBoundaryVar(BoundaryID bnd, MooseVariableFieldBase * var); + void addBoundaryVar(BoundaryID bnd, const MooseVariableFieldBase * var); /** * Add a variable to a set of boundaries * @param boundary_ids The boundary ids where this variable is defined * @param var The variable */ - void addBoundaryVar(const std::set & boundary_ids, MooseVariableFieldBase * var); + void addBoundaryVar(const std::set & boundary_ids, + const MooseVariableFieldBase * var); /** * Add a map of variables to a set of boundaries @@ -146,7 +147,7 @@ class VariableWarehouse * @param bnd The boundary ID * @return The list of variables */ - const std::set & boundaryVars(BoundaryID bnd) const; + const std::set & boundaryVars(BoundaryID bnd) const; /** * Get the list of scalar variables @@ -199,7 +200,7 @@ class VariableWarehouse std::map _var_name; /// Map to variables that need to be evaluated on a boundary - std::map> _boundary_vars; + std::map> _boundary_vars; /// list of all scalar, non-finite element variables std::vector _scalar_vars; diff --git a/framework/src/base/ResidualObject.C b/framework/src/base/ResidualObject.C new file mode 100644 index 000000000000..c19ad342e2dd --- /dev/null +++ b/framework/src/base/ResidualObject.C @@ -0,0 +1,64 @@ +//* This file is part of the MOOSE framework +//* https://www.mooseframework.org +//* +//* All rights reserved, see COPYRIGHT for full restrictions +//* https://github.com/idaholab/moose/blob/master/COPYRIGHT +//* +//* Licensed under LGPL 2.1, please see LICENSE for details +//* https://www.gnu.org/licenses/lgpl-2.1.html + +#include "ResidualObject.h" +#include "Assembly.h" +#include "MooseVariableFE.h" +#include "Problem.h" +#include "SubProblem.h" +#include "SystemBase.h" +#include "NonlinearSystem.h" + +#include "libmesh/threads.h" + +defineLegacyParams(ResidualObject); + +InputParameters +ResidualObject::validParams() +{ + auto params = MooseObject::validParams(); + params += TransientInterface::validParams(); + params += RandomInterface::validParams(); + params += MeshChangedInterface::validParams(); + params += TaggingInterface::validParams(); + + params.addRequiredParam( + "variable", "The name of the variable that this residual object operates on"); + + params.declareControllable("enable"); + return params; +} + +ResidualObject::ResidualObject(const InputParameters & parameters, bool is_nodal) + : MooseObject(parameters), + SetupInterface(this), + FunctionInterface(this), + UserObjectInterface(this), + TransientInterface(this), + PostprocessorInterface(this), + // VPPs used by ScalarKernels must be broadcast because we don't know where the + // ScalarKernel will end up being evaluated + // Note: residual objects should have a valid _moose_base. + VectorPostprocessorInterface(this, + parameters.get("_moose_base") == "ScalarKernel"), + RandomInterface(parameters, + *parameters.getCheckedPointerParam("_fe_problem_base"), + parameters.get("_tid"), + is_nodal), + Restartable(this, parameters.get("_moose_base") + "s"), + MeshChangedInterface(parameters), + TaggingInterface(this), + _subproblem(*getCheckedPointerParam("_subproblem")), + _fe_problem(*parameters.get("_fe_problem_base")), + _sys(*getCheckedPointerParam("_sys")), + _tid(parameters.get("_tid")), + _assembly(_subproblem.assembly(_tid)), + _mesh(_subproblem.mesh()) +{ +} diff --git a/framework/src/bcs/BoundaryCondition.C b/framework/src/bcs/BoundaryCondition.C index ae281c2dad11..08a594e22ca6 100644 --- a/framework/src/bcs/BoundaryCondition.C +++ b/framework/src/bcs/BoundaryCondition.C @@ -8,22 +8,15 @@ //* https://www.gnu.org/licenses/lgpl-2.1.html #include "BoundaryCondition.h" -#include "Problem.h" -#include "SystemBase.h" -#include "MooseVariableFE.h" defineLegacyParams(BoundaryCondition); InputParameters BoundaryCondition::validParams() { - InputParameters params = MooseObject::validParams(); - params += TransientInterface::validParams(); + InputParameters params = ResidualObject::validParams(); params += BoundaryRestrictableRequired::validParams(); - params += TaggingInterface::validParams(); - params.addRequiredParam( - "variable", "The name of the variable that this boundary condition applies to"); params.addParam("use_displaced_mesh", false, "Whether or not this object should use the " @@ -34,31 +27,15 @@ BoundaryCondition::validParams() params.addParamNamesToGroup("use_displaced_mesh", "Advanced"); params.addCoupledVar("displacements", "The displacements"); - params.declareControllable("enable"); params.registerBase("BoundaryCondition"); return params; } BoundaryCondition::BoundaryCondition(const InputParameters & parameters, bool nodal) - : MooseObject(parameters), + : ResidualObject(parameters, nodal), BoundaryRestrictableRequired(this, nodal), - SetupInterface(this), - FunctionInterface(this), DistributionInterface(this), - UserObjectInterface(this), - TransientInterface(this), - PostprocessorInterface(this), - VectorPostprocessorInterface(this), - GeometricSearchInterface(this), - Restartable(this, "BCs"), - MeshChangedInterface(parameters), - TaggingInterface(this), - _subproblem(*getCheckedPointerParam("_subproblem")), - _fe_problem(*getCheckedPointerParam("_fe_problem_base")), - _sys(*getCheckedPointerParam("_sys")), - _tid(parameters.get("_tid")), - _assembly(_subproblem.assembly(_tid)), - _mesh(_subproblem.mesh()) + GeometricSearchInterface(this) { } diff --git a/framework/src/bcs/IntegratedBCBase.C b/framework/src/bcs/IntegratedBCBase.C index e06affca2d3c..b59fd5995523 100644 --- a/framework/src/bcs/IntegratedBCBase.C +++ b/framework/src/bcs/IntegratedBCBase.C @@ -16,7 +16,6 @@ InputParameters IntegratedBCBase::validParams() { InputParameters params = BoundaryCondition::validParams(); - params += RandomInterface::validParams(); params += MaterialPropertyInterface::validParams(); params.addParam>( @@ -40,7 +39,6 @@ IntegratedBCBase::validParams() IntegratedBCBase::IntegratedBCBase(const InputParameters & parameters) : BoundaryCondition(parameters, false), // False is because this is NOT nodal - RandomInterface(parameters, _fe_problem, _tid, false), CoupleableMooseVariableDependencyIntermediateInterface(this, false), MaterialPropertyInterface(this, Moose::EMPTY_BLOCK_IDS, boundaryIDs()), _current_elem(_assembly.elem()), @@ -57,5 +55,3 @@ IntegratedBCBase::IntegratedBCBase(const InputParameters & parameters) _diag_save_in_strings(parameters.get>("diag_save_in")) { } - -IntegratedBCBase::~IntegratedBCBase() {} diff --git a/framework/src/bcs/NodalBCBase.C b/framework/src/bcs/NodalBCBase.C index e9348391e553..4bf5853b9c9a 100644 --- a/framework/src/bcs/NodalBCBase.C +++ b/framework/src/bcs/NodalBCBase.C @@ -15,7 +15,6 @@ InputParameters NodalBCBase::validParams() { InputParameters params = BoundaryCondition::validParams(); - params += RandomInterface::validParams(); params.addParam>( "save_in", "The name of auxiliary variables to save this BC's residual contributions to. " @@ -36,7 +35,6 @@ NodalBCBase::validParams() NodalBCBase::NodalBCBase(const InputParameters & parameters) : BoundaryCondition(parameters, true), // true is for being Nodal - RandomInterface(parameters, _fe_problem, _tid, true), CoupleableMooseVariableDependencyIntermediateInterface(this, true), _save_in_strings(parameters.get>("save_in")), _diag_save_in_strings(parameters.get>("diag_save_in")) diff --git a/framework/src/constraints/Constraint.C b/framework/src/constraints/Constraint.C index 661b18662df2..7998c9112d55 100644 --- a/framework/src/constraints/Constraint.C +++ b/framework/src/constraints/Constraint.C @@ -16,10 +16,7 @@ defineLegacyParams(Constraint); InputParameters Constraint::validParams() { - InputParameters params = MooseObject::validParams(); - // Add the SetupInterface parameter, 'execute_on', default is 'linear' - params += SetupInterface::validParams(); - params += TaggingInterface::validParams(); + InputParameters params = ResidualObject::validParams(); params.addParam("use_displaced_mesh", false, @@ -30,27 +27,12 @@ Constraint::validParams() "the undisplaced mesh will still be used."); params.addParamNamesToGroup("use_displaced_mesh", "Advanced"); - params.declareControllable("enable"); params.registerBase("Constraint"); return params; } Constraint::Constraint(const InputParameters & parameters) - : MooseObject(parameters), - SetupInterface(this), - FunctionInterface(this), - UserObjectInterface(this), - TransientInterface(this), - GeometricSearchInterface(this), - Restartable(this, "Constraints"), - MeshChangedInterface(parameters), - TaggingInterface(this), - _sys(*getCheckedPointerParam("_sys")), - _tid(parameters.get("_tid")), - _assembly(_subproblem.assembly(_tid)), - _mesh(_subproblem.mesh()) + : ResidualObject(parameters), GeometricSearchInterface(this) { } - -Constraint::~Constraint() {} diff --git a/framework/src/constraints/ConstraintWarehouse.C b/framework/src/constraints/ConstraintWarehouse.C index c0e3dec102b4..22c49ded6e15 100644 --- a/framework/src/constraints/ConstraintWarehouse.C +++ b/framework/src/constraints/ConstraintWarehouse.C @@ -315,7 +315,7 @@ ConstraintWarehouse::subdomainsCovered(std::set & subdomains_covere const auto & objects = pr.second.getActiveObjects(); for (const auto & mc : objects) { - const MooseVariableFEBase * lm_var = mc->variable(); + const MooseVariableFEBase * lm_var = &mc->variable(); if (lm_var) { unique_variables.insert(lm_var->name()); @@ -335,7 +335,7 @@ ConstraintWarehouse::subdomainsCovered(std::set & subdomains_covere const auto & objects = pr.second.getActiveObjects(); for (const auto & mc : objects) { - const MooseVariableFEBase * lm_var = mc->variable(); + const MooseVariableFEBase * lm_var = &mc->variable(); if (lm_var) { unique_variables.insert(lm_var->name()); diff --git a/framework/src/constraints/ElemElemConstraint.C b/framework/src/constraints/ElemElemConstraint.C index de17445d6880..99f11fd2db6e 100644 --- a/framework/src/constraints/ElemElemConstraint.C +++ b/framework/src/constraints/ElemElemConstraint.C @@ -26,8 +26,6 @@ ElemElemConstraint::validParams() { InputParameters params = Constraint::validParams(); params.addParam("interface_id", 0, "The id of the interface."); - params.addRequiredParam( - "variable", "The name of the variable that this constraint is applied to."); return params; } diff --git a/framework/src/constraints/MortarConstraintBase.C b/framework/src/constraints/MortarConstraintBase.C index dc44b093790d..8b0446652cb9 100644 --- a/framework/src/constraints/MortarConstraintBase.C +++ b/framework/src/constraints/MortarConstraintBase.C @@ -59,6 +59,7 @@ MortarConstraintBase::validParams() "primary_variable", "Primal variable on primary surface. If this parameter is not provided then the primary " "variable will be initialized to the secondary variable"); + // This parameter has been added. We add it again to update the doc string. params.addParam( "variable", "The name of the lagrange multiplier variable that this constraint is applied to. This " diff --git a/framework/src/constraints/NodalConstraint.C b/framework/src/constraints/NodalConstraint.C index c11fd1e0bec8..b909ebeb9d6e 100644 --- a/framework/src/constraints/NodalConstraint.C +++ b/framework/src/constraints/NodalConstraint.C @@ -26,8 +26,6 @@ NodalConstraint::validParams() params.addParam("formulation", formulationtype, "Formulation used to calculate constraint - penalty or kinematic."); - params.addRequiredParam( - "variable", "The name of the variable that this constraint is applied to."); return params; } diff --git a/framework/src/constraints/NodeElemConstraint.C b/framework/src/constraints/NodeElemConstraint.C index c9b303d63d64..3a40ecaf191a 100644 --- a/framework/src/constraints/NodeElemConstraint.C +++ b/framework/src/constraints/NodeElemConstraint.C @@ -28,8 +28,6 @@ NodeElemConstraint::validParams() params.addRequiredParam("primary", "primary block id"); params.addRequiredCoupledVar("primary_variable", "The variable on the primary side of the domain"); - params.addRequiredParam( - "variable", "The name of the variable that this constraint is applied to."); return params; } diff --git a/framework/src/constraints/NodeFaceConstraint.C b/framework/src/constraints/NodeFaceConstraint.C index 97f2c394af40..bbae1988d2bc 100644 --- a/framework/src/constraints/NodeFaceConstraint.C +++ b/framework/src/constraints/NodeFaceConstraint.C @@ -47,8 +47,6 @@ NodeFaceConstraint::validParams() params.addCoupledVar("primary_variable", "The variable on the primary side of the domain"); params.addDeprecatedCoupledVar("master_variable", "primary_variable", "September 1st, 2020"); - params.addRequiredParam( - "variable", "The name of the variable that this constraint is applied to."); return params; } diff --git a/framework/src/dgkernels/DGKernelBase.C b/framework/src/dgkernels/DGKernelBase.C index b61d5b59d3f6..56307af82d49 100644 --- a/framework/src/dgkernels/DGKernelBase.C +++ b/framework/src/dgkernels/DGKernelBase.C @@ -27,15 +27,10 @@ defineLegacyParams(DGKernelBase); InputParameters DGKernelBase::validParams() { - InputParameters params = MooseObject::validParams(); + InputParameters params = ResidualObject::validParams(); params += TwoMaterialPropertyInterface::validParams(); - params += TransientInterface::validParams(); params += BlockRestrictable::validParams(); params += BoundaryRestrictable::validParams(); - params += MeshChangedInterface::validParams(); - params += TaggingInterface::validParams(); - params.addRequiredParam( - "variable", "The name of the variable that this boundary condition applies to"); params.addParam("use_displaced_mesh", false, "Whether or not this object should use the " @@ -46,7 +41,6 @@ DGKernelBase::validParams() params.addPrivateParam("_use_undisplaced_reference_points", false); params.addParamNamesToGroup("use_displaced_mesh", "Advanced"); - params.declareControllable("enable"); params.addParam>( "save_in", "The name of auxiliary variables to save this Kernel's residual contributions to. " @@ -76,25 +70,12 @@ Threads::spin_mutex DGKernelBase::_resid_vars_mutex; Threads::spin_mutex DGKernelBase::_jacoby_vars_mutex; DGKernelBase::DGKernelBase(const InputParameters & parameters) - : MooseObject(parameters), + : ResidualObject(parameters), BlockRestrictable(this), BoundaryRestrictable(this, false), // false for _not_ nodal - SetupInterface(this), - TransientInterface(this), - FunctionInterface(this), - UserObjectInterface(this), NeighborCoupleableMooseVariableDependencyIntermediateInterface(this, false, false), TwoMaterialPropertyInterface(this, blockIDs(), boundaryIDs()), - Restartable(this, "DGKernels"), - MeshChangedInterface(parameters), - TaggingInterface(this), ElementIDInterface(this), - _subproblem(*getCheckedPointerParam("_subproblem")), - _sys(*getCheckedPointerParam("_sys")), - _tid(parameters.get("_tid")), - _assembly(_subproblem.assembly(_tid)), - _mesh(_subproblem.mesh()), - _current_elem(_assembly.elem()), _current_elem_volume(_assembly.elemVolume()), @@ -138,8 +119,6 @@ DGKernelBase::DGKernelBase(const InputParameters & parameters) _excluded_boundaries.insert(bnd_ids.begin(), bnd_ids.end()); } -DGKernelBase::~DGKernelBase() {} - void DGKernelBase::computeResidual() { diff --git a/framework/src/dirackernels/DiracKernel.C b/framework/src/dirackernels/DiracKernel.C index 3ee37f4605a7..0c0d740659cb 100644 --- a/framework/src/dirackernels/DiracKernel.C +++ b/framework/src/dirackernels/DiracKernel.C @@ -21,11 +21,8 @@ defineLegacyParams(DiracKernel); InputParameters DiracKernel::validParams() { - InputParameters params = MooseObject::validParams(); + InputParameters params = ResidualObject::validParams(); params += MaterialPropertyInterface::validParams(); - params += TaggingInterface::validParams(); - params.addRequiredParam( - "variable", "The name of the variable that this kernel operates on"); params.addParam("use_displaced_mesh", false, @@ -42,36 +39,22 @@ DiracKernel::validParams() params.addParamNamesToGroup("use_displaced_mesh drop_duplicate_points", "Advanced"); - params.declareControllable("enable"); params.registerBase("DiracKernel"); return params; } DiracKernel::DiracKernel(const InputParameters & parameters) - : MooseObject(parameters), - SetupInterface(this), + : ResidualObject(parameters), CoupleableMooseVariableDependencyIntermediateInterface(this, false), MooseVariableInterface(this, false, "variable", Moose::VarKindType::VAR_NONLINEAR, Moose::VarFieldType::VAR_FIELD_STANDARD), - FunctionInterface(this), - UserObjectInterface(this), - TransientInterface(this), MaterialPropertyInterface(this, Moose::EMPTY_BLOCK_IDS, Moose::EMPTY_BOUNDARY_IDS), - PostprocessorInterface(this), GeometricSearchInterface(this), - Restartable(this, "DiracKernels"), - MeshChangedInterface(parameters), - TaggingInterface(this), - _subproblem(*getCheckedPointerParam("_subproblem")), - _sys(*getCheckedPointerParam("_sys")), - _tid(parameters.get("_tid")), - _assembly(_subproblem.assembly(_tid)), _var(mooseVariableField()), - _mesh(_subproblem.mesh()), _coord_sys(_assembly.coordSystem()), _dirac_kernel_info(_subproblem.diracKernelInfo()), _current_elem(_var.currentElem()), @@ -449,18 +432,6 @@ DiracKernel::meshChanged() _reverse_point_cache.clear(); } -MooseVariableField & -DiracKernel::variable() -{ - return _var; -} - -SubProblem & -DiracKernel::subProblem() -{ - return _subproblem; -} - void DiracKernel::updateCaches(const Elem * old_elem, const Elem * new_elem, Point p, unsigned id) { diff --git a/framework/src/dirackernels/VectorPostprocessorPointSource.C b/framework/src/dirackernels/VectorPostprocessorPointSource.C index 59c92b755a32..b24893daa71b 100644 --- a/framework/src/dirackernels/VectorPostprocessorPointSource.C +++ b/framework/src/dirackernels/VectorPostprocessorPointSource.C @@ -42,7 +42,6 @@ VectorPostprocessorPointSource::validParams() VectorPostprocessorPointSource::VectorPostprocessorPointSource(const InputParameters & parameters) : DiracKernel(parameters), - VectorPostprocessorInterface(this), _use_broadcast(getParam("use_broadcast")), _vpp_values(getVectorPostprocessorValue( "vector_postprocessor", getParam("value_name"), _use_broadcast)), diff --git a/framework/src/interfacekernels/InterfaceKernelBase.C b/framework/src/interfacekernels/InterfaceKernelBase.C index d0c68cafaf08..47aede82e139 100644 --- a/framework/src/interfacekernels/InterfaceKernelBase.C +++ b/framework/src/interfacekernels/InterfaceKernelBase.C @@ -21,14 +21,9 @@ defineLegacyParams(InterfaceKernelBase); InputParameters InterfaceKernelBase::validParams() { - InputParameters params = MooseObject::validParams(); - params += TransientInterface::validParams(); + InputParameters params = ResidualObject::validParams(); params += BoundaryRestrictable::validParams(); - params += MeshChangedInterface::validParams(); - params += TaggingInterface::validParams(); - params.addRequiredParam( - "variable", "The name of the variable that this boundary condition applies to"); params.addParam("use_displaced_mesh", false, "Whether or not this object should use the " @@ -80,24 +75,11 @@ Threads::spin_mutex InterfaceKernelBase::_resid_vars_mutex; Threads::spin_mutex InterfaceKernelBase::_jacoby_vars_mutex; InterfaceKernelBase::InterfaceKernelBase(const InputParameters & parameters) - : MooseObject(parameters), + : ResidualObject(parameters), BoundaryRestrictable(this, false), // false for _not_ nodal - SetupInterface(this), - TransientInterface(this), - FunctionInterface(this), - UserObjectInterface(this), - PostprocessorInterface(this), NeighborCoupleableMooseVariableDependencyIntermediateInterface(this, false, false), - Restartable(this, "InterfaceKernels"), - MeshChangedInterface(parameters), TwoMaterialPropertyInterface(this, Moose::EMPTY_BLOCK_IDS, boundaryIDs()), - TaggingInterface(this), ElementIDInterface(this), - _subproblem(*getCheckedPointerParam("_subproblem")), - _sys(*getCheckedPointerParam("_sys")), - _tid(parameters.get("_tid")), - _assembly(_subproblem.assembly(_tid)), - _mesh(_subproblem.mesh()), _current_elem(_assembly.elem()), _current_elem_volume(_assembly.elemVolume()), _neighbor_elem(_assembly.neighbor()), diff --git a/framework/src/interfaces/ElementIDInterface.C b/framework/src/interfaces/ElementIDInterface.C index cddb619336f6..cb393611d861 100644 --- a/framework/src/interfaces/ElementIDInterface.C +++ b/framework/src/interfaces/ElementIDInterface.C @@ -21,7 +21,7 @@ ElementIDInterface::ElementIDInterface(const MooseObject * moose_object) : _obj_parameters(moose_object->parameters()), - _mesh(moose_object->getMooseApp().actionWarehouse().mesh()) + _id_mesh(moose_object->getMooseApp().actionWarehouse().mesh()) { } @@ -39,10 +39,10 @@ ElementIDInterface::getElementIDIndex(const std::string & id_parameter_name, unsigned int ElementIDInterface::getElementIDIndexByName(const std::string & id_name) const { - if (!_mesh.get()) + if (!_id_mesh.get()) mooseError("Mesh is not available for getting element integers"); - auto & mesh_base = _mesh->getMesh(); + auto & mesh_base = _id_mesh->getMesh(); if (id_name == "subdomain_id") { diff --git a/framework/src/kernels/KernelBase.C b/framework/src/kernels/KernelBase.C index 97fd167c0a6f..b95c5f83a021 100644 --- a/framework/src/kernels/KernelBase.C +++ b/framework/src/kernels/KernelBase.C @@ -22,16 +22,10 @@ defineLegacyParams(KernelBase); InputParameters KernelBase::validParams() { - auto params = MooseObject::validParams(); - params += TransientInterface::validParams(); + auto params = ResidualObject::validParams(); params += BlockRestrictable::validParams(); - params += RandomInterface::validParams(); - params += MeshChangedInterface::validParams(); params += MaterialPropertyInterface::validParams(); - params += TaggingInterface::validParams(); - params.addRequiredParam( - "variable", "The name of the variable that this Kernel operates on"); params.addParam>( "save_in", "The name of auxiliary variables to save this Kernel's residual contributions to. " @@ -53,37 +47,16 @@ KernelBase::validParams() params.addParamNamesToGroup(" diag_save_in save_in use_displaced_mesh", "Advanced"); params.addCoupledVar("displacements", "The displacements"); - - params.declareControllable("enable"); return params; } KernelBase::KernelBase(const InputParameters & parameters) - : MooseObject(parameters), + : ResidualObject(parameters), BlockRestrictable(this), - SetupInterface(this), CoupleableMooseVariableDependencyIntermediateInterface(this, false), - FunctionInterface(this), - UserObjectInterface(this), - TransientInterface(this), - PostprocessorInterface(this), - VectorPostprocessorInterface(this), MaterialPropertyInterface(this, blockIDs(), Moose::EMPTY_BOUNDARY_IDS), - RandomInterface(parameters, - *parameters.getCheckedPointerParam("_fe_problem_base"), - parameters.get("_tid"), - false), GeometricSearchInterface(this), - Restartable(this, "Kernels"), - MeshChangedInterface(parameters), - TaggingInterface(this), ElementIDInterface(this), - _subproblem(*getCheckedPointerParam("_subproblem")), - _fe_problem(*parameters.get("_fe_problem_base")), - _sys(*getCheckedPointerParam("_sys")), - _tid(parameters.get("_tid")), - _assembly(_subproblem.assembly(_tid)), - _mesh(_subproblem.mesh()), _current_elem(_assembly.elem()), _current_elem_volume(_assembly.elemVolume()), _q_point(_assembly.qPoints()), @@ -99,5 +72,3 @@ KernelBase::KernelBase(const InputParameters & parameters) for (decltype(num_disp) i = 0; i < num_disp; ++i) _displacements.push_back(coupled("displacements", i)); } - -KernelBase::~KernelBase() {} diff --git a/framework/src/kernels/ScalarKernel.C b/framework/src/kernels/ScalarKernel.C index 805c3460fd03..a0c9c3d41984 100644 --- a/framework/src/kernels/ScalarKernel.C +++ b/framework/src/kernels/ScalarKernel.C @@ -20,12 +20,7 @@ defineLegacyParams(ScalarKernel); InputParameters ScalarKernel::validParams() { - InputParameters params = MooseObject::validParams(); - params += TransientInterface::validParams(); - params += TaggingInterface::validParams(); - params.addRequiredParam( - "variable", "The name of the variable that this kernel operates on"); - + InputParameters params = ResidualObject::validParams(); params.addParam("use_displaced_mesh", false, "Whether or not this object should use the " @@ -35,56 +30,16 @@ ScalarKernel::validParams() "the undisplaced mesh will still be used."); params.addParamNamesToGroup("use_displaced_mesh", "Advanced"); - params.declareControllable("enable"); - params.registerBase("ScalarKernel"); return params; } ScalarKernel::ScalarKernel(const InputParameters & parameters) - : MooseObject(parameters), + : ResidualObject(parameters), ScalarCoupleable(this), - SetupInterface(this), - FunctionInterface(this), - UserObjectInterface(this), - PostprocessorInterface(this), - TransientInterface(this), - MeshChangedInterface(parameters), - // VPPs used by ScalarKernels must be broadcast because we don't know where the - // ScalarKernel will end up being evaluated - VectorPostprocessorInterface(this, /*broadcast_by_default=*/true), - TaggingInterface(this), - _subproblem(*getCheckedPointerParam("_subproblem")), - _sys(*getCheckedPointerParam("_sys")), - _tid(parameters.get("_tid")), - _assembly(_subproblem.assembly(_tid)), _var(_sys.getScalarVariable(_tid, parameters.get("variable"))), - _mesh(_subproblem.mesh()), _u(_is_implicit ? _var.sln() : _var.slnOld()), _u_old(_var.slnOld()) { } - -void -ScalarKernel::computeOffDiagJacobian(unsigned int /*jvar*/) -{ -} - -bool -ScalarKernel::isActive() -{ - return true; -} - -MooseVariableScalar & -ScalarKernel::variable() -{ - return _var; -} - -SubProblem & -ScalarKernel::subProblem() -{ - return _subproblem; -} diff --git a/framework/src/nodalkernels/NodalKernel.C b/framework/src/nodalkernels/NodalKernel.C index 86eafeb9997d..7fa7a3c45b85 100644 --- a/framework/src/nodalkernels/NodalKernel.C +++ b/framework/src/nodalkernels/NodalKernel.C @@ -19,15 +19,9 @@ defineLegacyParams(NodalKernel); InputParameters NodalKernel::validParams() { - InputParameters params = MooseObject::validParams(); - params += TransientInterface::validParams(); + InputParameters params = ResidualObject::validParams(); params += BlockRestrictable::validParams(); params += BoundaryRestrictable::validParams(); - params += RandomInterface::validParams(); - params += TaggingInterface::validParams(); - - params.addRequiredParam( - "variable", "The name of the variable that this boundary condition applies to"); params.addParam>( "save_in", @@ -50,43 +44,24 @@ NodalKernel::validParams() "the undisplaced mesh will still be used."); params.addParamNamesToGroup("use_displaced_mesh", "Advanced"); - params.declareControllable("enable"); - params.registerBase("NodalKernel"); return params; } NodalKernel::NodalKernel(const InputParameters & parameters) - : MooseObject(parameters), + : ResidualObject(parameters, true), 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("_fe_problem_base"), - parameters.get("_tid"), - true), CoupleableMooseVariableDependencyIntermediateInterface(this, true), MooseVariableInterface(this, true, "variable", Moose::VarKindType::VAR_NONLINEAR, Moose::VarFieldType::VAR_FIELD_STANDARD), - TaggingInterface(this), - _subproblem(*getCheckedPointerParam("_subproblem")), _fe_problem(*getCheckedPointerParam("_fe_problem_base")), - _sys(*getCheckedPointerParam("_sys")), - _tid(parameters.get("_tid")), - _assembly(_subproblem.assembly(_tid)), _var(*mooseVariable()), - _mesh(_subproblem.mesh()), _current_node(_var.node()), _u(_var.dofValues()), _save_in_strings(parameters.get>("save_in")), @@ -131,18 +106,6 @@ NodalKernel::NodalKernel(const InputParameters & parameters) _has_diag_save_in = _diag_save_in.size() > 0; } -MooseVariable & -NodalKernel::variable() -{ - return _var; -} - -SubProblem & -NodalKernel::subProblem() -{ - return _subproblem; -} - void NodalKernel::computeResidual() { diff --git a/framework/src/systems/NonlinearEigenSystem.C b/framework/src/systems/NonlinearEigenSystem.C index 6560febc054a..4a457933aa41 100644 --- a/framework/src/systems/NonlinearEigenSystem.C +++ b/framework/src/systems/NonlinearEigenSystem.C @@ -206,7 +206,13 @@ NonlinearEigenSystem::markEigenVariables(MooseObjectTagWarehouse & warehouse) auto & mtags = object->getMatrixTags(); // If it is an eigen kernel, mark its variable as eigen if (vtags.find(_Bx_tag) != vtags.end() || mtags.find(_B_tag) != mtags.end()) - object->variable().eigen(true); + { + auto vname = object->variable().name(); + if (hasScalarVariable(vname)) + getScalarVariable(0, vname).eigen(true); + else + getVariable(0, vname).eigen(true); + } } } } diff --git a/framework/src/systems/NonlinearSystemBase.C b/framework/src/systems/NonlinearSystemBase.C index 865ab0d65b94..2546f4265a1e 100644 --- a/framework/src/systems/NonlinearSystemBase.C +++ b/framework/src/systems/NonlinearSystemBase.C @@ -468,7 +468,8 @@ NonlinearSystemBase::addBoundaryCondition(const std::string & bc_name, // Active BoundaryIDs for the object const std::set & boundary_ids = bc->boundaryIDs(); - _vars[tid].addBoundaryVar(boundary_ids, &bc->variable()); + auto bc_var = dynamic_cast(&bc->variable()); + _vars[tid].addBoundaryVar(boundary_ids, bc_var); // Cast to the various types of BCs std::shared_ptr nbc = std::dynamic_pointer_cast(bc); @@ -520,7 +521,7 @@ NonlinearSystemBase::addBoundaryCondition(const std::string & bc_name, // Active BoundaryIDs for the object const std::set & boundary_ids = bc->boundaryIDs(); - _vars[tid].addBoundaryVar(boundary_ids, &bc->variable()); + _vars[tid].addBoundaryVar(boundary_ids, bc_var); ibc = std::static_pointer_cast(bc); @@ -588,7 +589,8 @@ NonlinearSystemBase::addInterfaceKernel(std::string interface_kernel_name, _factory.create(interface_kernel_name, name, parameters, tid); const std::set & boundary_ids = interface_kernel->boundaryIDs(); - _vars[tid].addBoundaryVar(boundary_ids, &interface_kernel->variable()); + auto ik_var = dynamic_cast(&interface_kernel->variable()); + _vars[tid].addBoundaryVar(boundary_ids, ik_var); _interface_kernels.addObject(interface_kernel, tid); _vars[tid].addBoundaryVars(boundary_ids, interface_kernel->getCoupledVars()); diff --git a/framework/src/systems/SystemBase.C b/framework/src/systems/SystemBase.C index 41244404ec69..c03438712730 100644 --- a/framework/src/systems/SystemBase.C +++ b/framework/src/systems/SystemBase.C @@ -188,7 +188,7 @@ SystemBase::getActualFieldVariable(THREAD_ID tid, unsigned int var_number) } MooseVariableScalar & -SystemBase::getScalarVariable(THREAD_ID tid, const std::string & var_name) +SystemBase::getScalarVariable(THREAD_ID tid, const std::string & var_name) const { MooseVariableScalar * var = dynamic_cast(_vars[tid].getVariable(var_name)); if (!var) @@ -197,7 +197,7 @@ SystemBase::getScalarVariable(THREAD_ID tid, const std::string & var_name) } MooseVariableScalar & -SystemBase::getScalarVariable(THREAD_ID tid, unsigned int var_number) +SystemBase::getScalarVariable(THREAD_ID tid, unsigned int var_number) const { MooseVariableScalar * var = dynamic_cast(_vars[tid].getVariable(var_number)); diff --git a/framework/src/variables/VariableWarehouse.C b/framework/src/variables/VariableWarehouse.C index 535956984512..77baa80a6b56 100644 --- a/framework/src/variables/VariableWarehouse.C +++ b/framework/src/variables/VariableWarehouse.C @@ -56,14 +56,14 @@ VariableWarehouse::add(const std::string & var_name, std::shared_ptr & boundary_ids, - MooseVariableFEBase * var) + const MooseVariableFEBase * var) { for (const auto & bid : boundary_ids) addBoundaryVar(bid, var); @@ -118,7 +118,7 @@ VariableWarehouse::scalars() const return _scalar_vars; } -const std::set & +const std::set & VariableWarehouse::boundaryVars(BoundaryID bnd) const { return _boundary_vars.find(bnd)->second; diff --git a/test/tests/restrictable/check_error/tests b/test/tests/restrictable/check_error/tests index 1601ce7cf701..b5ae91dba9da 100644 --- a/test/tests/restrictable/check_error/tests +++ b/test/tests/restrictable/check_error/tests @@ -10,8 +10,7 @@ type = 'RunException' input = 'check_error.i' cli_args = "Kernels/diff/test=fe_problem_null" - expect_err = "The input parameters must contain a pointer to FEProblem via '_fe_problem' or a " - "pointer to the MooseMesh via '_mesh'" + expect_err = "Parameter _fe_problem_base is NULL" detail = "regarding the problem being solved or" @@ -21,8 +20,7 @@ type = 'RunException' input = 'check_error.i' cli_args = "Kernels/diff/test=mesh_null" - expect_err = "The input parameters must contain a pointer to FEProblem via '_fe_problem' or a " - "pointer to the MooseMesh via '_mesh'" + expect_err = "Parameter _fe_problem_base is NULL" detail = "information regarding the finite element mesh." []