diff --git a/framework/include/constraints/ADMortarScalarBase.h b/framework/include/constraints/ADMortarScalarBase.h index 1535ed8d38a8..bb8fd129d41d 100644 --- a/framework/include/constraints/ADMortarScalarBase.h +++ b/framework/include/constraints/ADMortarScalarBase.h @@ -62,9 +62,12 @@ class ADMortarScalarBase : public ADMortarConstraint */ virtual void initScalarQpResidual() {} - /// Whether to compute scalar contributions + /// Whether a scalar variable is declared for this constraint const bool _use_scalar; + /// Whether to compute scalar contributions for this instance + const bool _compute_scalar_residuals; + /// A dummy object useful for constructing _kappa when not using scalars const ADVariableValue _kappa_dummy; diff --git a/framework/include/constraints/MortarScalarBase.h b/framework/include/constraints/MortarScalarBase.h index ef50a0068d60..87a070b9ca62 100644 --- a/framework/include/constraints/MortarScalarBase.h +++ b/framework/include/constraints/MortarScalarBase.h @@ -130,9 +130,12 @@ class MortarScalarBase : public MortarConstraint { } - /// Whether to compute scalar contributions + /// Whether a scalar variable is declared for this constraint const bool _use_scalar; + /// Whether to compute scalar contributions for this instance + const bool _compute_scalar_residuals; + /// A dummy object useful for constructing _kappa when not using scalars const VariableValue _kappa_dummy; diff --git a/framework/include/kernels/ADKernelScalarBase.h b/framework/include/kernels/ADKernelScalarBase.h index 3231ec98ef64..77d405a0b501 100644 --- a/framework/include/kernels/ADKernelScalarBase.h +++ b/framework/include/kernels/ADKernelScalarBase.h @@ -72,9 +72,15 @@ class ADKernelScalarBase : public ADKernel */ virtual void initScalarQpResidual() {} - /// Whether to compute scalar contributions + /// Whether a scalar variable is declared for this kernel const bool _use_scalar; + /// Whether to compute scalar contributions for this instance + const bool _compute_scalar_residuals; + + /// Whether to compute field contributions for this instance + const bool _compute_field_residuals; + /// A dummy object useful for constructing _kappa when not using scalars const ADVariableValue _kappa_dummy; diff --git a/framework/include/kernels/KernelScalarBase.h b/framework/include/kernels/KernelScalarBase.h index 75706aee9b3e..fa9755c180b3 100644 --- a/framework/include/kernels/KernelScalarBase.h +++ b/framework/include/kernels/KernelScalarBase.h @@ -106,9 +106,15 @@ class KernelScalarBase : public Kernel */ virtual void initScalarQpOffDiagJacobian(const MooseVariableFEBase &) {} - /// Whether to compute scalar contributions + /// Whether a scalar variable is declared for this kernel const bool _use_scalar; + /// Whether to compute scalar contributions for this instance + const bool _compute_scalar_residuals; + + /// Whether to compute field contributions for this instance + const bool _compute_field_residuals; + /// A dummy object useful for constructing _kappa when not using scalars const VariableValue _kappa_dummy; diff --git a/framework/src/constraints/ADMortarScalarBase.C b/framework/src/constraints/ADMortarScalarBase.C index b622262458dd..f310fa328c9e 100644 --- a/framework/src/constraints/ADMortarScalarBase.C +++ b/framework/src/constraints/ADMortarScalarBase.C @@ -25,12 +25,14 @@ ADMortarScalarBase::validParams() // This name is fixed and required to be equal to the previous parameter; need to add error // checks... params.addCoupledVar("coupled_scalar", "Repeat name of scalar variable to ensure dependency"); + params.addParam("compute_scalar_residuals", true, "Whether to compute scalar residuals"); return params; } ADMortarScalarBase::ADMortarScalarBase(const InputParameters & parameters) : ADMortarConstraint(parameters), _use_scalar(isParamValid("scalar_variable") ? true : false), + _compute_scalar_residuals(!_use_scalar ? false : getParam("compute_scalar_residuals")), _kappa_dummy(), _kappa_var_ptr( _use_scalar ? &_sys.getScalarVariable(_tid, parameters.get("scalar_variable")) @@ -47,7 +49,7 @@ ADMortarScalarBase::computeResidual() { ADMortarConstraint::computeResidual(); - if (_use_scalar) + if (_compute_scalar_residuals) { std::vector scalar_residuals(_k_order); for (_qp = 0; _qp < _qrule_msm->n_points(); _qp++) @@ -71,7 +73,7 @@ ADMortarScalarBase::computeJacobian() // d-_var-residual / d-_var and d-_var-residual / d-jvar ADMortarConstraint::computeJacobian(); - if (_use_scalar) + if (_compute_scalar_residuals) { std::vector scalar_residuals; scalar_residuals.resize(_k_order, 0); diff --git a/framework/src/constraints/MortarConstraintBase.C b/framework/src/constraints/MortarConstraintBase.C index bf20246b01a9..0f8343594b4b 100644 --- a/framework/src/constraints/MortarConstraintBase.C +++ b/framework/src/constraints/MortarConstraintBase.C @@ -73,7 +73,6 @@ MortarConstraintBase::validParams() "compute_primal_residuals", true, "Whether to compute residuals for the primal variable."); params.addParam( "compute_lm_residuals", true, "Whether to compute Lagrange Multiplier residuals"); - params.addParam("compute_scalar_residuals", true, "Whether to compute scalar residuals"); params.addParam( "quadrature", MooseEnum("DEFAULT FIRST SECOND THIRD FOURTH", "DEFAULT"), diff --git a/framework/src/constraints/MortarScalarBase.C b/framework/src/constraints/MortarScalarBase.C index ace290d432d4..2f6df5e4ce3d 100644 --- a/framework/src/constraints/MortarScalarBase.C +++ b/framework/src/constraints/MortarScalarBase.C @@ -24,12 +24,14 @@ MortarScalarBase::validParams() // This name is fixed and required to be equal to the previous parameter; need to add error // checks... params.addCoupledVar("coupled_scalar", "Repeat name of scalar variable to ensure dependency"); + params.addParam("compute_scalar_residuals", true, "Whether to compute scalar residuals"); return params; } MortarScalarBase::MortarScalarBase(const InputParameters & parameters) : MortarConstraint(parameters), _use_scalar(isParamValid("scalar_variable") ? true : false), + _compute_scalar_residuals(!_use_scalar ? false : getParam("compute_scalar_residuals")), _kappa_dummy(), _kappa_var_ptr( _use_scalar ? &_sys.getScalarVariable(_tid, parameters.get("scalar_variable")) @@ -47,7 +49,7 @@ MortarScalarBase::computeResidual() { MortarConstraintBase::computeResidual(); - if (_use_scalar) + if (_compute_scalar_residuals) { std::vector scalar_residuals(_k_order); for (_qp = 0; _qp < _qrule_msm->n_points(); _qp++) @@ -98,42 +100,45 @@ MortarScalarBase::computeJacobian() // Compute the jacobian for the lower dimensional LM dofs (if we even have an LM variable) computeOffDiagJacobianScalar(Moose::MortarType::Lower, jvariable->number()); - // Handle ALL d-_kappa-residual / d-_var and d-_kappa-residual / d-jvar columns - auto & ce = _assembly.scalarFieldCouplingEntries(); - for (const auto & it : ce) + if (_compute_scalar_residuals) { - MooseVariableScalar & ivariable = *(it.first); - MooseVariableFEBase & jvariable = *(it.second); + // Handle ALL d-_kappa-residual / d-_var and d-_kappa-residual / d-jvar columns + auto & ce = _assembly.scalarFieldCouplingEntries(); + for (const auto & it : ce) + { + MooseVariableScalar & ivariable = *(it.first); + MooseVariableFEBase & jvariable = *(it.second); - unsigned int ivar = ivariable.number(); - unsigned int jvar_num = jvariable.number(); + unsigned int ivar = ivariable.number(); + unsigned int jvar_num = jvariable.number(); - if (ivar != _kappa_var) // only do the row for _kappa_var in this object - continue; + if (ivar != _kappa_var) // only do the row for _kappa_var in this object + continue; - if (_compute_primal_residuals) - { - // Compute the jacobian for the secondary interior primal dofs - computeScalarOffDiagJacobian(Moose::MortarType::Secondary, jvar_num); - // Compute the jacobian for the primary interior primal dofs. - computeScalarOffDiagJacobian(Moose::MortarType::Primary, jvar_num); + if (_compute_primal_residuals) + { + // Compute the jacobian for the secondary interior primal dofs + computeScalarOffDiagJacobian(Moose::MortarType::Secondary, jvar_num); + // Compute the jacobian for the primary interior primal dofs. + computeScalarOffDiagJacobian(Moose::MortarType::Primary, jvar_num); + } + if (_compute_lm_residuals) + // Compute the jacobian for the lower dimensional LM dofs (if we even have an LM variable) + computeScalarOffDiagJacobian(Moose::MortarType::Lower, jvar_num); } - if (_compute_lm_residuals) - // Compute the jacobian for the lower dimensional LM dofs (if we even have an LM variable) - computeScalarOffDiagJacobian(Moose::MortarType::Lower, jvar_num); - } - // Do: d-_kappa-residual / d-_kappa and d-_kappa-residual / d-jvar, - // only want to process only nl-variables (not aux ones) - for (const auto & jvariable : coupled_scalar_vars) - { - if (_sys.hasScalarVariable(jvariable->name())) + // Do: d-_kappa-residual / d-_kappa and d-_kappa-residual / d-jvar, + // only want to process only nl-variables (not aux ones) + for (const auto & jvariable : coupled_scalar_vars) { - const unsigned int jvar_num = jvariable->number(); - if (jvar_num == _kappa_var) - computeScalarJacobian(); // d-_kappa-residual / d-_kappa - else - computeScalarOffDiagJacobianScalar(jvar_num); // d-_kappa-residual / d-jvar + if (_sys.hasScalarVariable(jvariable->name())) + { + const unsigned int jvar_num = jvariable->number(); + if (jvar_num == _kappa_var) + computeScalarJacobian(); // d-_kappa-residual / d-_kappa + else + computeScalarOffDiagJacobianScalar(jvar_num); // d-_kappa-residual / d-jvar + } } } } diff --git a/framework/src/kernels/ADKernelScalarBase.C b/framework/src/kernels/ADKernelScalarBase.C index bdbf593ede16..58b9f90073c8 100644 --- a/framework/src/kernels/ADKernelScalarBase.C +++ b/framework/src/kernels/ADKernelScalarBase.C @@ -27,12 +27,17 @@ ADKernelScalarBase::validParams() // This name is fixed and required to be equal to the previous parameter; need to add error // checks... params.addCoupledVar("coupled_scalar", "Repeat name of scalar variable to ensure dependency"); + params.addParam("compute_scalar_residuals", true, "Whether to compute scalar residuals"); + params.addParam( + "compute_field_residuals", true, "Whether to compute residuals for the field variable."); return params; } ADKernelScalarBase::ADKernelScalarBase(const InputParameters & parameters) : ADKernel(parameters), _use_scalar(isParamValid("scalar_variable") ? true : false), + _compute_scalar_residuals(!_use_scalar ? false : getParam("compute_scalar_residuals")), + _compute_field_residuals(getParam("compute_field_residuals")), _kappa_dummy(), _kappa_var_ptr( _use_scalar ? &_sys.getScalarVariable(_tid, parameters.get("scalar_variable")) @@ -52,9 +57,10 @@ ADKernelScalarBase::ADKernelScalarBase(const InputParameters & parameters) void ADKernelScalarBase::computeResidual() { - ADKernel::computeResidual(); // compute and assemble regular variable contributions + if (_compute_field_residuals) + ADKernel::computeResidual(); // compute and assemble regular variable contributions - if (_use_scalar) + if (_compute_scalar_residuals) { std::vector scalar_residuals(_k_order); for (_qp = 0; _qp < _qrule->n_points(); _qp++) @@ -75,12 +81,13 @@ ADKernelScalarBase::computeResidual() void ADKernelScalarBase::computeJacobian() { - ADKernel::computeJacobian(); + if (_compute_field_residuals) + ADKernel::computeJacobian(); #ifndef MOOSE_SPARSE_AD mooseError("ADKernelScalarBase assembly only supported for non-sparse AD"); #else - if (_use_scalar) + if (_compute_scalar_residuals) { computeScalarResidualsForJacobian(); _assembly.processResidualsAndJacobian(_scalar_residuals, @@ -108,12 +115,13 @@ ADKernelScalarBase::computeOffDiagJacobianScalar(const unsigned int /*jvar_num*/ void ADKernelScalarBase::computeResidualAndJacobian() { - ADKernel::computeResidualAndJacobian(); + if (_compute_field_residuals) + ADKernel::computeResidualAndJacobian(); #ifndef MOOSE_SPARSE_AD mooseError("ADKernelScalarBase assembly only supported for non-sparse AD"); #else - if (_use_scalar) + if (_compute_scalar_residuals) { computeScalarResidualsForJacobian(); _assembly.processResidualsAndJacobian(_scalar_residuals, diff --git a/framework/src/kernels/KernelScalarBase.C b/framework/src/kernels/KernelScalarBase.C index e846017293b2..5be475d9a43d 100644 --- a/framework/src/kernels/KernelScalarBase.C +++ b/framework/src/kernels/KernelScalarBase.C @@ -26,12 +26,17 @@ KernelScalarBase::validParams() // This name is fixed and required to be equal to the previous parameter; need to add error // checks... params.addCoupledVar("coupled_scalar", "Repeat name of scalar variable to ensure dependency"); + params.addParam("compute_scalar_residuals", true, "Whether to compute scalar residuals"); + params.addParam( + "compute_field_residuals", true, "Whether to compute residuals for the field variable."); return params; } KernelScalarBase::KernelScalarBase(const InputParameters & parameters) : Kernel(parameters), _use_scalar(isParamValid("scalar_variable") ? true : false), + _compute_scalar_residuals(!_use_scalar ? false : getParam("compute_scalar_residuals")), + _compute_field_residuals(getParam("compute_field_residuals")), _kappa_dummy(), _kappa_var_ptr( _use_scalar ? &_sys.getScalarVariable(_tid, parameters.get("scalar_variable")) @@ -47,9 +52,10 @@ KernelScalarBase::KernelScalarBase(const InputParameters & parameters) void KernelScalarBase::computeResidual() { - Kernel::computeResidual(); // compute and assemble regular variable contributions + if (_compute_field_residuals) + Kernel::computeResidual(); // compute and assemble regular variable contributions - if (_use_scalar) + if (_compute_scalar_residuals) computeScalarResidual(); } @@ -74,9 +80,10 @@ KernelScalarBase::computeScalarResidual() void KernelScalarBase::computeJacobian() { - Kernel::computeJacobian(); + if (_compute_field_residuals) + Kernel::computeJacobian(); - if (_use_scalar) + if (_compute_scalar_residuals) computeScalarJacobian(); } @@ -108,8 +115,10 @@ KernelScalarBase::computeOffDiagJacobian(const unsigned int jvar_num) { if (jvar_num == variable().number()) // column for this kernel's variable { - Kernel::computeJacobian(); // d-_var-residual / d-_var - computeScalarOffDiagJacobian(jvar_num); // d-_kappa-residual / d-_var + if (_compute_field_residuals) + Kernel::computeJacobian(); // d-_var-residual / d-_var + if (_compute_scalar_residuals) + computeScalarOffDiagJacobian(jvar_num); // d-_kappa-residual / d-_var } else if (jvar_num == _kappa_var) // column for this kernel's scalar variable { @@ -118,19 +127,23 @@ KernelScalarBase::computeOffDiagJacobian(const unsigned int jvar_num) } else // some other column for regular variable { - Kernel::computeOffDiagJacobian(jvar_num); // d-_var-residual / d-jvar - computeScalarOffDiagJacobian(jvar_num); // d-_kappa-residual / d-jvar + if (_compute_field_residuals) + Kernel::computeOffDiagJacobian(jvar_num); // d-_var-residual / d-jvar + if (_compute_scalar_residuals) + computeScalarOffDiagJacobian(jvar_num); // d-_kappa-residual / d-jvar } } else { if (jvar_num == variable().number()) // column for this kernel's variable { - Kernel::computeJacobian(); // d-_var-residual / d-_var + if (_compute_field_residuals) + Kernel::computeJacobian(); // d-_var-residual / d-_var } else // some other column for regular variable { - Kernel::computeOffDiagJacobian(jvar_num); // d-_var-residual / d-jvar + if (_compute_field_residuals) + Kernel::computeOffDiagJacobian(jvar_num); // d-_var-residual / d-jvar } } } @@ -205,19 +218,23 @@ KernelScalarBase::computeOffDiagJacobianScalar(const unsigned int svar_num) // Perform assembly using method in Kernel; works for simple cases but not general // Kernel::computeOffDiagJacobianScalar(svar_num); // d-_var-residual / d-_kappa // Perform assembly using local_ke like d-_kappa_var-residual / d-_var - computeOffDiagJacobianScalarLocal(svar_num); // d-_var-residual / d-_kappa - computeScalarJacobian(); // d-_kappa-residual / d-_kappa + if (_compute_field_residuals) + computeOffDiagJacobianScalarLocal(svar_num); // d-_var-residual / d-_kappa + if (_compute_scalar_residuals) + computeScalarJacobian(); // d-_kappa-residual / d-_kappa } else // some other column for scalar variable { // Perform assembly using method in Kernel; works for simple cases but not general // Kernel::computeOffDiagJacobianScalar(svar_num); // d-_var-residual / d-jvar // Perform assembly using local_ke like d-_kappa_var-residual / d-_var - computeOffDiagJacobianScalarLocal(svar_num); // d-_var-residual / d-svar - computeScalarOffDiagJacobianScalar(svar_num); // d-_kappa-residual / d-svar + if (_compute_field_residuals) + computeOffDiagJacobianScalarLocal(svar_num); // d-_var-residual / d-svar + if (_compute_scalar_residuals) + computeScalarOffDiagJacobianScalar(svar_num); // d-_kappa-residual / d-svar } } - else + else if (_compute_field_residuals) Kernel::computeOffDiagJacobianScalar(svar_num); // d-_var-residual / d-svar } diff --git a/modules/tensor_mechanics/test/include/kernels/HomogenizedTotalLagrangianStressDivergenceA.h b/modules/tensor_mechanics/test/include/kernels/HomogenizedTotalLagrangianStressDivergenceA.h index db197f018e2d..76dee98920cf 100644 --- a/modules/tensor_mechanics/test/include/kernels/HomogenizedTotalLagrangianStressDivergenceA.h +++ b/modules/tensor_mechanics/test/include/kernels/HomogenizedTotalLagrangianStressDivergenceA.h @@ -36,10 +36,10 @@ typedef std::map, std::pair, std::pair> + ConstraintMap; +} + +/// Total Lagrangian formulation with most homogenization terms (one disp_xyz field and one scalar) +/// The macro_gradient variable is split into two scalars: the first component called '_hvar' +/// herein and all other components called '_avar' herein. For parameter _beta = 0, the primary +/// scalar (_kappa) is _hvar and the coupled scalar is _avar. For parameter _beta = 1, the primary +/// scalar (_kappa) is _avar and the coupled scalar is _hvar. Just like the primary field variable +/// (_var) is either disp_x or disp_y or disp_z depending on _alpha. +/// +/// Thus, each instance of HomogenizedTotalLagrangianStressDivergenceR acts on one field variable +/// (_disp_alpha) and one scalar variable (_hvar_beta). The job of the kernel is to assemble the +/// residual of all dofs of _disp_alpha and of all dofs of _hvar_beta (namely, selected rows). +/// Also, it assembles the ENTIRE row for _disp_alpha and _hvar_beta (namely the columns +/// from all dofs of all _disp field variables and all dofs of all scalar variables _hvar and +/// _avar). The rows for the other field/scalar variables are handled by other instances of the +/// kernel, according to the flags compute_scalar_residuals and compute_field_residuals. +/// When compute_field_residuals is given, only component=_alpha matters and beta = {0,1} is looped. +/// When compute_scalar_residuals is given, only prime_scalar=_beta matters and alpha = {0,1,2} is looped. +/// +/// In summary, for x=disp_x etc. and h=_hvar and a=_avar, then the contributions of the instances are +/// _alpha=0 +/// R = [Rx, 00, 00, Rh, 00 ]^T +/// J = [Jxx, Jxy, Jxz, Jxh, Jxa] +/// _alpha=1 +/// R = [00, Ry, 00, 00, 00 ]^T +/// J = [Jyx, Jyy, Jyz, Jyh, Jya] +/// _alpha=2 +/// R = [00, 00, Rz, 00, 00 ]^T +/// J = [Jzx, Jzy, Jzz, Jzh, Jza] +/// _beta=0 +/// R = [00, 00, 00, Rh, 00 ]^T +/// J = [Jhx, Jhy, Jhz, Jhh, Jha] +/// _beta=1 +/// R = [00, 00, 00, 00, Ra ]^T +/// J = [Jax, Jay, Jaz, Jah, Jaa] +/// +/// In this manner, the full R and J are obtained with NO duplication of jobs: +/// R = [Rx, Ry, Rz, Rh, Ra ]^T +/// J = [Jxx, Jxy, Jxz, Jxh, Jxa +/// Jxy, Jyy, Jyz, Jyh, Jya +/// Jzx, Jzy, Jzz, Jzh, Jza +/// Jhx, Jhy, Jhz, Jhh, Jha +/// Jax, Jay, Jaz, Jah, Jaa] +/// +class HomogenizedTotalLagrangianStressDivergenceR : public TotalLagrangianStressDivergenceS +{ +public: + static InputParameters validParams(); + HomogenizedTotalLagrangianStressDivergenceR(const InputParameters & parameters); + +protected: + // Add overrides to base class contributions to only happen for _beta==0, to happen only once + virtual Real computeQpResidual() override; + virtual Real computeQpJacobianDisplacement(unsigned int alpha, unsigned int beta) override; + + /** + * Method for computing the scalar part of residual for _kappa + */ + virtual void computeScalarResidual() override; + + /** + * Method for computing the scalar variable part of Jacobian for d-_kappa-residual / d-_kappa + */ + virtual void computeScalarJacobian() override; + + /** + * Method for computing an off-diagonal jacobian component d-_kappa-residual / d-jvar + * jvar is looped over all field variables, which herein is just disp_x and disp_y + */ + virtual void computeScalarOffDiagJacobian(const unsigned int jvar_num) override; + + /** + * Method for computing an off-diagonal jacobian component at quadrature points. + */ + virtual Real computeScalarQpOffDiagJacobian(const unsigned int jvar_num) override; + + /** + * Method for computing an off-diagonal jacobian component d-_var-residual / d-svar. + * svar is looped over all scalar variables, which herein is just _kappa and _kappa_other + */ + virtual void computeOffDiagJacobianScalarLocal(const unsigned int svar_num) override; + + /** + * Method for computing d-_var-residual / d-_svar at quadrature points. + */ + virtual Real computeQpOffDiagJacobianScalar(const unsigned int /*svar_num*/) override; + + /** + * Method for computing an off-diagonal jacobian component d-_kappa-residual / d-svar + * svar is looped over other scalar variables, which herein is just _kappa_other + */ + virtual void computeScalarOffDiagJacobianScalar(const unsigned int svar_num) override; + +protected: + /// Which component of the scalar vector residual this constraint is responsible for + const unsigned int _beta; + + /// (Pointer to) Scalar variable this kernel operates on + const MooseVariableScalar * const _kappao_var_ptr; + + /// The unknown scalar variable ID + const unsigned int _kappao_var; + + /// Order of the scalar variable, used in several places + const unsigned int _ko_order; + + /// Reference to the current solution at the current quadrature point + const VariableValue & _kappa_other; + + /// Type of each constraint (stress or strain) for each component + HomogenizationR::ConstraintMap _cmap; + + /// The constraint type; initialize with 'none' + HomogenizationR::ConstraintType _ctype = HomogenizationR::ConstraintType::None; + + /// Used internally to iterate over each scalar component + unsigned int _m; + unsigned int _n; + unsigned int _a; + unsigned int _b; +}; diff --git a/modules/tensor_mechanics/test/include/kernels/HomogenizedTotalLagrangianStressDivergenceS.h b/modules/tensor_mechanics/test/include/kernels/HomogenizedTotalLagrangianStressDivergenceS.h index 582bb0cf99ac..db523cd263c2 100644 --- a/modules/tensor_mechanics/test/include/kernels/HomogenizedTotalLagrangianStressDivergenceS.h +++ b/modules/tensor_mechanics/test/include/kernels/HomogenizedTotalLagrangianStressDivergenceS.h @@ -66,7 +66,7 @@ class HomogenizedTotalLagrangianStressDivergenceS : public TotalLagrangianStress /** * Method for computing d-_var-residual / d-svar at quadrature points. */ - virtual Real computeQpOffDiagJacobianScalar(const unsigned int jvar) override; + virtual Real computeQpOffDiagJacobianScalar(const unsigned int svar_num) override; protected: /// Type of each constraint (stress or strain) for each component diff --git a/modules/tensor_mechanics/test/src/kernels/HomogenizedTotalLagrangianStressDivergenceR.C b/modules/tensor_mechanics/test/src/kernels/HomogenizedTotalLagrangianStressDivergenceR.C new file mode 100644 index 000000000000..da51c2585766 --- /dev/null +++ b/modules/tensor_mechanics/test/src/kernels/HomogenizedTotalLagrangianStressDivergenceR.C @@ -0,0 +1,469 @@ +//* 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 "HomogenizedTotalLagrangianStressDivergenceR.h" + +// MOOSE includes +#include "Function.h" +#include "MooseVariableScalar.h" +// #include "Assembly.h" +// #include "MooseVariableFE.h" +// #include "MooseVariableScalar.h" +// #include "SystemBase.h" + +// #include "libmesh/quadrature.h" + +registerMooseObject("TensorMechanicsTestApp", HomogenizedTotalLagrangianStressDivergenceR); + +namespace +{ +const InputParameters & +setHTLSDRParam(const InputParameters & params_in) +{ + // Reset the scalar_variable parameter to a relevant name for this physics + InputParameters & ret = const_cast(params_in); + ret.set("scalar_variable") = {params_in.get("macro_var")}; + return ret; +} +} + +InputParameters +HomogenizedTotalLagrangianStressDivergenceR::validParams() +{ + InputParameters params = TotalLagrangianStressDivergenceS::validParams(); + params.addClassDescription("Total Lagrangian stress equilibrium kernel with " + "homogenization constraint Jacobian terms"); + params.addRequiredParam("macro_var", + "Optional scalar field with the macro gradient"); + params.addRequiredCoupledVar("macro_other", "Other components of coupled scalar variable"); + params.addRequiredParam("prime_scalar", "Either 0=_var or 1=_other scalar"); + params.addRequiredParam( + "constraint_types", + HomogenizationR::constraintType, + "Type of each constraint: strain, stress, or none. The types are specified in the " + "column-major order, and there must be 9 entries in total."); + params.addRequiredParam>( + "targets", "Functions giving the targets to hit for constraint types that are not none."); + + return params; +} + +HomogenizedTotalLagrangianStressDivergenceR::HomogenizedTotalLagrangianStressDivergenceR( + const InputParameters & parameters) + : TotalLagrangianStressDivergenceS(setHTLSDRParam(parameters)), + _beta(getParam("prime_scalar")), + _kappao_var_ptr(getScalarVar("macro_other", 0)), + _kappao_var(coupledScalar("macro_other")), + _ko_order(getScalarVar("macro_other", 0)->order()), + _kappa_other(coupledScalarValue("macro_other")) +{ + // Constraint types + auto types = getParam("constraint_types"); + if (types.size() != Moose::dim * Moose::dim) + mooseError("Number of constraint types must equal dim * dim. ", types.size(), " are provided."); + + // Targets to hit + const std::vector & fnames = getParam>("targets"); + + // Prepare the constraint map + unsigned int fcount = 0; + for (const auto j : make_range(Moose::dim)) + for (const auto i : make_range(Moose::dim)) + { + const auto idx = i + Moose::dim * j; + const auto ctype = static_cast(types.get(idx)); + if (ctype != HomogenizationR::ConstraintType::None) + { + const Function * const f = &getFunctionByName(fnames[fcount++]); + _cmap[{i, j}] = {ctype, f}; + } + } +} + +Real +HomogenizedTotalLagrangianStressDivergenceR::computeQpResidual() +{ + // Assemble R_alpha + return gradTest(_alpha).doubleContraction(_pk1[_qp]); +} + +Real +HomogenizedTotalLagrangianStressDivergenceR::computeQpJacobianDisplacement(unsigned int alpha, + unsigned int beta) +{ + // Assemble J-alpha-beta + return gradTest(alpha).doubleContraction(_dpk1[_qp] * gradTrial(beta)); +} + +void +HomogenizedTotalLagrangianStressDivergenceR::computeScalarResidual() +{ + std::vector scalar_residuals(_k_order); + + for (_qp = 0; _qp < _qrule->n_points(); _qp++) + { + initScalarQpResidual(); + Real dV = _JxW[_qp] * _coord[_qp]; + _h = 0; // single index for residual vector; double indices for constraint tensor component + for (auto && [indices, constraint] : _cmap) + { + auto && [i, j] = indices; + auto && [ctype, ctarget] = constraint; + + // ONLY the component(s) that this constraint will contribute here; + // other one is handled in the other constraint + if (_beta == 0) + { + if (_h == 1) // only assemble first=0 component of _hvar, then break the loop + break; + } + else + { + // skip the first component (_hvar) and continue to "first" component of _avar + if (_h == 0) + { + _h++; + continue; + } + } + + // I am not great with C++ precedence; so, store the index + unsigned int r_ind = -_beta + _h; // move 1 row up if _beta=1 for the other scalar + _h++; // increment the index before we forget + if (_large_kinematics) + { + if (ctype == HomogenizationR::ConstraintType::Stress) + scalar_residuals[r_ind] += dV * (_pk1[_qp](i, j) - ctarget->value(_t, _q_point[_qp])); + else if (ctype == HomogenizationR::ConstraintType::Strain) + scalar_residuals[r_ind] += + dV * (_F[_qp](i, j) - (Real(i == j) + ctarget->value(_t, _q_point[_qp]))); + else + mooseError("Unknown constraint type in the integral!"); + } + else + { + if (ctype == HomogenizationR::ConstraintType::Stress) + scalar_residuals[r_ind] += dV * (_pk1[_qp](i, j) - ctarget->value(_t, _q_point[_qp])); + else if (ctype == HomogenizationR::ConstraintType::Strain) + scalar_residuals[r_ind] += dV * (0.5 * (_F[_qp](i, j) + _F[_qp](j, i)) - + (Real(i == j) + ctarget->value(_t, _q_point[_qp]))); + else + mooseError("Unknown constraint type in the integral!"); + } + } + } + + _assembly.processResiduals(scalar_residuals, + _kappa_var_ptr->dofIndices(), + _vector_tags, + _kappa_var_ptr->scalingFactor()); +} + +void +HomogenizedTotalLagrangianStressDivergenceR::computeScalarJacobian() +{ + _local_ke.resize(_k_order, _k_order); + + for (_qp = 0; _qp < _qrule->n_points(); _qp++) + { + initScalarQpJacobian(_kappa_var); + Real dV = _JxW[_qp] * _coord[_qp]; + + _h = 0; + for (auto && [indices1, constraint1] : _cmap) + { + auto && [i, j] = indices1; + auto && ctype = constraint1.first; + + // identical logic to computeScalarResidual + if (_beta == 0) + { + if (_h == 1) + break; + } + else + { + if (_h == 0) + { + _h++; + continue; + } + } + + _l = 0; + for (auto && indices2 : _cmap) + { + auto && [a, b] = indices2.first; + + // identical logic to computeScalarResidual, but for column index + if (_beta == 0) + { + if (_l == 1) + break; + } + else + { + if (_l == 0) + { + _l++; + continue; + } + } + + unsigned int c_ind = -_beta + _l; // move 1 column left if _beta=1 for the other scalar + _l++; // increment the index before we forget + if (ctype == HomogenizationR::ConstraintType::Stress) + _local_ke(-_beta + _h, c_ind) += dV * (_dpk1[_qp](i, j, a, b)); + else if (ctype == HomogenizationR::ConstraintType::Strain) + { + if (_large_kinematics) + _local_ke(-_beta + _h, c_ind) += dV * (Real(i == a && j == b)); + else + _local_ke(-_beta + _h, c_ind) += + dV * (0.5 * Real(i == a && j == b) + 0.5 * Real(i == b && j == a)); + } + else + mooseError("Unknown constraint type in Jacobian calculator!"); + } + _h++; + } + } + + for (const auto & matrix_tag : _matrix_tags) + _assembly.cacheJacobianBlock(_local_ke, + _kappa_var_ptr->dofIndices(), + _kappa_var_ptr->dofIndices(), + _kappa_var_ptr->scalingFactor(), + matrix_tag); +} + +void +HomogenizedTotalLagrangianStressDivergenceR::computeScalarOffDiagJacobian( + const unsigned int jvar_num) +{ + // Bail if jvar not coupled + if (getJvarMap()[jvar_num] >= 0) + { + + const auto & jvar = getVariable(jvar_num); + _local_ke.resize(_k_order, _test.size()); + + for (_qp = 0; _qp < _qrule->n_points(); _qp++) + { + // single index for Jacobian column; double indices for constraint tensor component + unsigned int h = 0; + Real dV = _JxW[_qp] * _coord[_qp]; + for (auto && [indices, constraint] : _cmap) + { + // identical logic to computeScalarResidual + if (_beta == 0) + { + if (h == 1) + break; + } + else + { + if (h == 0) + { + h++; + continue; + } + } + // copy constraint indices to protected variables to pass to Qp routine + _m = indices.first; + _n = indices.second; + _ctype = constraint.first; + initScalarQpOffDiagJacobian(_var); + for (_j = 0; _j < _test.size(); _j++) + _local_ke(-_beta + h, _j) += dV * computeScalarQpOffDiagJacobian(jvar_num); + h++; + } + } + + for (const auto & matrix_tag : _matrix_tags) + _assembly.cacheJacobianBlock(_local_ke, + _kappa_var_ptr->dofIndices(), + jvar.dofIndices(), + _kappa_var_ptr->scalingFactor(), + matrix_tag); + } +} + +void +HomogenizedTotalLagrangianStressDivergenceR::computeOffDiagJacobianScalarLocal( + const unsigned int svar_num) +{ + // Bail if jvar not coupled + if ((svar_num == _kappa_var) || (svar_num == _kappao_var)) + { + // Get dofs and order of this scalar; at least one will be _kappa_var + const auto & svar = _sys.getScalarVariable(_tid, svar_num); + const unsigned int s_order = svar.order(); + _local_ke.resize(_test.size(), s_order); + + // set the local beta based on the current svar_num + unsigned int beta = 0; + if (svar_num == _kappa_var) + beta = 0; + else // svar_num == _kappao_var + beta = 1; + + for (_qp = 0; _qp < _qrule->n_points(); _qp++) + { + // single index for Jacobian row; double indices for constraint tensor component + unsigned int l = 0; + Real dV = _JxW[_qp] * _coord[_qp]; + for (auto && [indices, constraint] : _cmap) + { + // identical logic to computeScalarResidual, but for column index + if (beta == 0) + { + if (l == 1) + break; + } + else + { + if (l == 0) + { + l++; + continue; + } + } + // copy constraint indices to protected variables to pass to Qp routine + _m = indices.first; + _n = indices.second; + _ctype = constraint.first; + initScalarQpJacobian(svar_num); + for (_i = 0; _i < _test.size(); _i++) + { + _local_ke(_i, -beta + l) += dV * computeQpOffDiagJacobianScalar(svar_num); + } + l++; + } + } + + for (const auto & matrix_tag : _matrix_tags) + _assembly.cacheJacobianBlock( + _local_ke, _var.dofIndices(), svar.dofIndices(), _var.scalingFactor(), matrix_tag); + } +} + +Real +HomogenizedTotalLagrangianStressDivergenceR::computeQpOffDiagJacobianScalar( + unsigned int /*svar_num*/) +{ + return _dpk1[_qp].contractionKl(_m, _n, gradTest(_alpha)); +} + +Real +HomogenizedTotalLagrangianStressDivergenceR::computeScalarQpOffDiagJacobian(unsigned int jvar_num) +{ + // set the local alpha based on the current jvar_num + for (auto alpha : make_range(_ndisp)) + { + if (jvar_num == _disp_nums[alpha]) + { + if (_ctype == HomogenizationR::ConstraintType::Stress) + return _dpk1[_qp].contractionIj(_m, _n, gradTrial(alpha)); + else if (_ctype == HomogenizationR::ConstraintType::Strain) + if (_large_kinematics) + return Real(_m == alpha) * gradTrial(alpha)(_m, _n); + else + return 0.5 * (Real(_m == alpha) * gradTrial(alpha)(_m, _n) + + Real(_n == alpha) * gradTrial(alpha)(_n, _m)); + else + mooseError("Unknown constraint type in kernel calculation!"); + } + } + return 0.0; +} + +void +HomogenizedTotalLagrangianStressDivergenceR::computeScalarOffDiagJacobianScalar( + const unsigned int svar_num) +{ + // Only do this for the other macro variable + if (svar_num == _kappao_var) + { + _local_ke.resize(_k_order, _ko_order); + + for (_qp = 0; _qp < _qrule->n_points(); _qp++) + { + initScalarQpJacobian(_kappa_var); + Real dV = _JxW[_qp] * _coord[_qp]; + + _h = 0; + for (auto && [indices1, constraint1] : _cmap) + { + auto && [i, j] = indices1; + auto && ctype = constraint1.first; + + // identical logic to computeScalarResidual + if (_beta == 0) + { + if (_h == 1) + break; + } + else + { + if (_h == 0) + { + _h++; + continue; + } + } + + _l = 0; + for (auto && indices2 : _cmap) + { + auto && [a, b] = indices2.first; + + // OPPOSITE logic/scalar from computeScalarResidual, AND for column index + if (_beta == 1) + { + if (_l == 1) // only assemble first=0 component of _hvar, then break the loop + break; + } + else + { + if (_l == 0) // skip first component (_hvar) & continue to "first" component of _avar + { + _l++; + continue; + } + } + + unsigned int c_ind = + -(1 - _beta) + _l; // DON'T move 1 column left if _beta=1 for the other scalar + _l++; + if (ctype == HomogenizationR::ConstraintType::Stress) + _local_ke(-_beta + _h, c_ind) += dV * (_dpk1[_qp](i, j, a, b)); + else if (ctype == HomogenizationR::ConstraintType::Strain) + { + if (_large_kinematics) + _local_ke(-_beta + _h, c_ind) += dV * (Real(i == a && j == b)); + else + _local_ke(-_beta + _h, c_ind) += + dV * (0.5 * Real(i == a && j == b) + 0.5 * Real(i == b && j == a)); + } + else + mooseError("Unknown constraint type in Jacobian calculator!"); + } + _h++; + } + } + + for (const auto & matrix_tag : _matrix_tags) + _assembly.cacheJacobianBlock(_local_ke, + _kappa_var_ptr->dofIndices(), + _kappao_var_ptr->dofIndices(), + _kappa_var_ptr->scalingFactor(), + matrix_tag); + } +} diff --git a/modules/tensor_mechanics/test/tests/lagrangian/cartesian/total/homogenization/scalar_kernel/2drow.i b/modules/tensor_mechanics/test/tests/lagrangian/cartesian/total/homogenization/scalar_kernel/2drow.i new file mode 100644 index 000000000000..ee05c416b069 --- /dev/null +++ b/modules/tensor_mechanics/test/tests/lagrangian/cartesian/total/homogenization/scalar_kernel/2drow.i @@ -0,0 +1,335 @@ +# 2D with mixed conditions on stress/strain + +[GlobalParams] + displacements = 'disp_x disp_y' + large_kinematics = false +[] + +[Mesh] + [base] + type = FileMeshGenerator + file = '2d.exo' + [] + + [sidesets] + type = SideSetsFromNormalsGenerator + input = base + normals = '-1 0 0 + 1 0 0 + 0 -1 0 + 0 1 0' + fixed_normal = true + new_boundary = 'left right bottom top' + [] +[] + +[Variables] + [disp_x] + [] + [disp_y] + [] + [hvar] + family = SCALAR + order = FIRST + [] + [hvarA] + family = SCALAR + order = SECOND + [] +[] + +[AuxVariables] + [sxx] + family = MONOMIAL + order = CONSTANT + [] + [syy] + family = MONOMIAL + order = CONSTANT + [] + [sxy] + family = MONOMIAL + order = CONSTANT + [] + [exx] + family = MONOMIAL + order = CONSTANT + [] + [eyy] + family = MONOMIAL + order = CONSTANT + [] + [exy] + family = MONOMIAL + order = CONSTANT + [] +[] + +[AuxKernels] + [sxx] + type = RankTwoAux + variable = sxx + rank_two_tensor = pk1_stress + index_i = 0 + index_j = 0 + [] + [syy] + type = RankTwoAux + variable = syy + rank_two_tensor = pk1_stress + index_i = 1 + index_j = 1 + [] + [sxy] + type = RankTwoAux + variable = sxy + rank_two_tensor = pk1_stress + index_i = 0 + index_j = 1 + [] + [exx] + type = RankTwoAux + variable = exx + rank_two_tensor = mechanical_strain + index_i = 0 + index_j = 0 + [] + [eyy] + type = RankTwoAux + variable = eyy + rank_two_tensor = mechanical_strain + index_i = 1 + index_j = 1 + [] + [exy] + type = RankTwoAux + variable = exy + rank_two_tensor = mechanical_strain + index_i = 0 + index_j = 1 + [] +[] + +[Kernels] + [sdx] + type = HomogenizedTotalLagrangianStressDivergenceR + variable = disp_x + component = 0 + coupled_scalar = hvar + macro_var = hvar + macro_other = hvarA + prime_scalar = 0 + compute_field_residuals = true + compute_scalar_residuals = false + constraint_types = ${constraint_types} + targets = ${targets} + [] + [sdy] + type = HomogenizedTotalLagrangianStressDivergenceR + variable = disp_y + component = 1 + coupled_scalar = hvar + macro_var = hvar + macro_other = hvarA + prime_scalar = 0 + compute_field_residuals = true + compute_scalar_residuals = false + constraint_types = ${constraint_types} + targets = ${targets} + [] + [sd0] + type = HomogenizedTotalLagrangianStressDivergenceR + variable = disp_x + component = 0 + coupled_scalar = hvar + macro_var = hvar + macro_other = hvarA + prime_scalar = 0 + compute_field_residuals = false + compute_scalar_residuals = true + constraint_types = ${constraint_types} + targets = ${targets} + [] + [sd1] + type = HomogenizedTotalLagrangianStressDivergenceR + variable = disp_y + component = 1 + coupled_scalar = hvarA + macro_var = hvarA + macro_other = hvar + prime_scalar = 1 + compute_field_residuals = false + compute_scalar_residuals = true + constraint_types = ${constraint_types} + targets = ${targets} + [] +[] + +# This seems to be needed so that the scalar variable is +# 'detected' and added to the system. Otherwise this message: +# *** ERROR *** +# Variable 'scalar_variable' does not exist in this system +[ScalarKernels] + [null] + type = NullScalarKernel + variable = hvar + [] + [nullA] + type = NullScalarKernel + variable = hvarA + [] +[] + +[Functions] + [strain11] + type = ParsedFunction + value = '4.0e-2*t' + [] + [strain22] + type = ParsedFunction + value = '-2.0e-2*t' + [] + [strain12] + type = ParsedFunction + value = '1.0e-2*t' + [] + [stress11] + type = ParsedFunction + value = '400*t' + [] + [stress22] + type = ParsedFunction + value = '-200*t' + [] + [stress12] + type = ParsedFunction + value = '100*t' + [] +[] + +[BCs] + [Periodic] + [x] + variable = disp_x + auto_direction = 'x y' + [] + [y] + variable = disp_y + auto_direction = 'x y' + [] + [] + + [fix1_x] + type = DirichletBC + boundary = "fix1" + variable = disp_x + value = 0 + [] + [fix1_y] + type = DirichletBC + boundary = "fix1" + variable = disp_y + value = 0 + [] + + [fix2_y] + type = DirichletBC + boundary = "fix2" + variable = disp_y + value = 0 + [] +[] + +[Materials] + [elastic_tensor_1] + type = ComputeIsotropicElasticityTensor + youngs_modulus = 100000.0 + poissons_ratio = 0.3 + block = '1' + [] + [elastic_tensor_2] + type = ComputeIsotropicElasticityTensor + youngs_modulus = 120000.0 + poissons_ratio = 0.21 + block = '2' + [] + [elastic_tensor_3] + type = ComputeIsotropicElasticityTensor + youngs_modulus = 80000.0 + poissons_ratio = 0.4 + block = '3' + [] + [compute_stress] + type = ComputeLagrangianLinearElasticStress + [] + [compute_strain] + type = ComputeLagrangianStrain + homogenization_gradient_names = 'homogenization_gradient' + [] + [compute_homogenization_gradient] + type = ComputeHomogenizedLagrangianStrainA + macro_gradientA = hvar + macro_gradient = hvarA + constraint_types = ${constraint_types} + targets = ${targets} + [] +[] + +[Postprocessors] + [sxx] + type = ElementAverageValue + variable = sxx + execute_on = 'initial timestep_end' + [] + [syy] + type = ElementAverageValue + variable = syy + execute_on = 'initial timestep_end' + [] + [sxy] + type = ElementAverageValue + variable = sxy + execute_on = 'initial timestep_end' + [] + [exx] + type = ElementAverageValue + variable = exx + execute_on = 'initial timestep_end' + [] + [eyy] + type = ElementAverageValue + variable = eyy + execute_on = 'initial timestep_end' + [] + [exy] + type = ElementAverageValue + variable = exy + execute_on = 'initial timestep_end' + [] +[] + +[Executioner] + type = Transient + + solve_type = 'newton' +# solve_type = 'PJFNK' + line_search = none + + petsc_options_iname = '-pc_type' + petsc_options_value = 'lu' + + l_max_its = 2 + l_tol = 1e-14 + nl_max_its = 30 + nl_rel_tol = 1e-8 + nl_abs_tol = 1e-10 + + start_time = 0.0 + dt = 0.2 + dtmin = 0.2 + end_time = 1.0 +[] + +[Outputs] + csv = true +[] diff --git a/modules/tensor_mechanics/test/tests/lagrangian/cartesian/total/homogenization/scalar_kernel/gold/2drow_out.csv b/modules/tensor_mechanics/test/tests/lagrangian/cartesian/total/homogenization/scalar_kernel/gold/2drow_out.csv new file mode 100644 index 000000000000..78352e5d7f98 --- /dev/null +++ b/modules/tensor_mechanics/test/tests/lagrangian/cartesian/total/homogenization/scalar_kernel/gold/2drow_out.csv @@ -0,0 +1,7 @@ +time,exx,exy,eyy,sxx,sxy,syy,hvar,hvarA_0,hvarA_1 +0,0,0,0,0,0,0,0,0,0 +0.2,0.00096026311741124,0.00030401429687746,-0.00080769950780423,80.000000000007,20,-39.999999999991,0.00096026311741122,0.00060802859375492,-0.00080769950780428 +0.4,0.0019205262348225,0.00060802859375492,-0.0016153990156086,160.00000000001,40,-80,0.0019205262348224,0.0012160571875098,-0.0016153990156086 +0.6,0.0028807893522336,0.00091204289063238,-0.0024230985234128,239.99999999999,60,-120.00000000001,0.0028807893522336,0.0018240857812648,-0.0024230985234128 +0.8,0.0038410524696449,0.0012160571875098,-0.0032307980312172,319.99999999999,80,-160.00000000001,0.0038410524696449,0.0024321143750197,-0.0032307980312171 +1,0.0048013155870561,0.0015200714843873,-0.0040384975390213,400,100,-199.99999999999,0.0048013155870561,0.0030401429687746,-0.0040384975390213 diff --git a/modules/tensor_mechanics/test/tests/lagrangian/cartesian/total/homogenization/scalar_kernel/tests b/modules/tensor_mechanics/test/tests/lagrangian/cartesian/total/homogenization/scalar_kernel/tests index 2e3e2d78f359..778a8016af3a 100644 --- a/modules/tensor_mechanics/test/tests/lagrangian/cartesian/total/homogenization/scalar_kernel/tests +++ b/modules/tensor_mechanics/test/tests/lagrangian/cartesian/total/homogenization/scalar_kernel/tests @@ -38,4 +38,13 @@ requirement = "Framework scalar kernel wrapper correctly assembles scalar-to-scalar coupling Jacobian" allow_test_objects = true [] + [2d-stressR] + type = CSVDiff + input = '2drow.i' + csvdiff = '2drow_out.csv' + cli_args = "constraint_types='stress none none stress stress " + "none none none none' targets='stress11 stress12 stress22'" + requirement = "Framework scalar kernel wrapper correctly assembles Jacobian by rows" + allow_test_objects = true + [] [] diff --git a/test/tests/kernels/ad_scalar_kernel_constraint/tests b/test/tests/kernels/ad_scalar_kernel_constraint/tests index 4275b9298dac..832c0361c1dd 100644 --- a/test/tests/kernels/ad_scalar_kernel_constraint/tests +++ b/test/tests/kernels/ad_scalar_kernel_constraint/tests @@ -17,7 +17,7 @@ run_sim = True input = 'scalar_constraint_kernel_RJ.i' ad_indexing_type = 'global' - detail = 'showing the correct results with separate computation of residual and Jacobian' + detail = 'and then verifying the separated Jacobian' cli_args = 'Executioner/residual_and_jacobian_together=false' prereq = 'kernel_dirichlet/physics_separate' [../] @@ -36,7 +36,7 @@ run_sim = True input = 'scalar_constraint_kernel_RJ.i' ad_indexing_type = 'global' - detail = 'showing the correct results with computation of residual and Jacobian together' + detail = 'and then verifying the Jacobian together' cli_args = 'Executioner/residual_and_jacobian_together=true' prereq = 'kernel_dirichlet/physics_together' [../] @@ -51,14 +51,14 @@ # This problem only has 4 elements and therefore does not seem to run on > 4 procs. cli_args = 'Executioner/residual_and_jacobian_together=false' ad_indexing_type = 'global' - detail = 'showing the correct results with separate computation of residual and Jacobian' + detail = 'showing the correct results with separate computation of residual and Jacobian for Neumann' [../] [jacobian_separate] type = 'PetscJacobianTester' run_sim = True input = 'scalar_constraint_together.i' ad_indexing_type = 'global' - detail = 'showing the correct results with separate computation of residual and Jacobian' + detail = 'and then verifying the separated Jacobian for Neumann' cli_args = 'Executioner/residual_and_jacobian_together=false' prereq = 'kernel_neumann/physics_separate' [../] @@ -69,7 +69,7 @@ # This problem only has 4 elements and therefore does not seem to run on > 4 procs. cli_args = 'Executioner/residual_and_jacobian_together=true' ad_indexing_type = 'global' - detail = 'showing the correct results with computation of residual and Jacobian together' + detail = 'showing the correct results with computation of residual and Jacobian together for Neumann' prereq = 'kernel_neumann/jacobian_separate' [../] [jacobian_together] @@ -77,7 +77,7 @@ run_sim = True input = 'scalar_constraint_together.i' ad_indexing_type = 'global' - detail = 'showing the correct results with computation of residual and Jacobian together' + detail = 'and then verifying the Jacobian together for Neumann' cli_args = 'Executioner/residual_and_jacobian_together=true' prereq = 'kernel_neumann/physics_together' [../] diff --git a/test/tests/mortar/periodic_segmental_constraint/gold/penalty_periodic_simple2d_out.e b/test/tests/mortar/periodic_segmental_constraint/gold/penalty_periodic_simple2d_out.e deleted file mode 100644 index 9ae12f0d9ebe..000000000000 Binary files a/test/tests/mortar/periodic_segmental_constraint/gold/penalty_periodic_simple2d_out.e and /dev/null differ diff --git a/test/tests/mortar/periodic_segmental_constraint/gold/periodic_simple2d_out.e b/test/tests/mortar/periodic_segmental_constraint/gold/periodic_simple2d_out.e deleted file mode 100644 index 00e7a83f7327..000000000000 Binary files a/test/tests/mortar/periodic_segmental_constraint/gold/periodic_simple2d_out.e and /dev/null differ diff --git a/test/tests/mortar/periodic_segmental_constraint/penalty_periodic_simple2d.i b/test/tests/mortar/periodic_segmental_constraint/penalty_periodic_simple2d.i index cbd452357037..7ae345a8749e 100644 --- a/test/tests/mortar/periodic_segmental_constraint/penalty_periodic_simple2d.i +++ b/test/tests/mortar/periodic_segmental_constraint/penalty_periodic_simple2d.i @@ -164,6 +164,5 @@ [] [Outputs] - exodus = true csv = true []