AD and non-AD shifted cohesive zone interface kernel for the small-strain formulation. More...

#include <SCZMInterfaceKernelSmallStrain.h>

Inheritance diagram for SCZMInterfaceKernelSmallStrainTempl< is_ad >:

Public Types
typedef std::vector< int >	JvarMap

Public Member Functions
	SCZMInterfaceKernelSmallStrainTempl (const InputParameters &parameters)

virtual void	computeOffDiagJacobian (unsigned int jvar) override

unsigned int	mapJvarToCvar (unsigned int jvar)

int	mapJvarToCvar (unsigned int jvar, const JvarMap &jvar_map)

bool	mapJvarToCvar (unsigned int jvar, unsigned int &cvar)

const JvarMap &	getJvarMap ()

const JvarMap &	getParameterJvarMap (std::string parameter_name)

Static Public Member Functions
static InputParameters	validParams ()

Protected Member Functions
GenericReal< is_ad >	computeQpResidual (Moose::DGResidualType type) override

Real	computeQpJacobian (Moose::DGJacobianType type) override

Real	computeQpOffDiagJacobian (Moose::DGJacobianType type, unsigned int jvar) override

Real	computeDResidualDDisplacement (unsigned int component_j, Moose::DGJacobianType type) const

Real	calculateDirectionalCorrectionJacobian (unsigned int ivar, unsigned int jvar, Moose::DGJacobianType type) const

Real	computeDResidualDDisplacement (unsigned int, Moose::DGJacobianType) const

Real	computeDResidualDDisplacement (unsigned int component_j, Moose::DGJacobianType type) const

Real	calculateDirectionalCorrectionJacobian (unsigned int ivar, unsigned int jvar, Moose::DGJacobianType type) const

Real	computeQpJacobian (Moose::DGJacobianType)

Real	computeQpJacobian (Moose::DGJacobianType type)

Real	computeQpOffDiagJacobian (Moose::DGJacobianType, unsigned int)

Real	computeQpOffDiagJacobian (Moose::DGJacobianType type, unsigned int jvar)

Real	calculateDirectionalCorrectionJacobian (unsigned int, unsigned int, Moose::DGJacobianType) const

bool	perform_shifted () const override
	Whether to apply the shifted integration corrections.

Protected Attributes
const bool	_directional_correction
	Whether to add the directional correction term.

bool	_volumetric_locking_correction
	Whether to apply the volumetric locking correction to the directional correction term.

	usingGenericInterfaceKernelMembers

const std::string	_base_name
	Base name of the material system that this kernel applies to.

const unsigned int	_component
	The displacement component this kernel is operating on (0=x, 1=y, 2=z)

const unsigned int	_ndisp
	Number of displacement components.

const GenericMaterialProperty< RealVectorValue, is_ad > &	_traction_global
	Traction in the global frame.

const bool	_shifted
	True by default; false only when requesting the non-shifted verification baseline.

const unsigned int	_n_args


const GenericMaterialProperty< RankTwoTensor, is_ad > &	_stress
	The stress tensor on the element and neighbor sides.

const GenericMaterialProperty< RankTwoTensor, is_ad > &	_stress_neighbor


std::vector< unsigned int >	_disp_var
	Non-AD data used by the hand-coded Jacobian.

std::vector< MooseVariable * >	_vars

const MaterialProperty< RankTwoTensor > *	_dtraction_djump_global

const MaterialProperty< RankFourTensor > *	_Jacobian_mult

const MaterialProperty< RankFourTensor > *	_Jacobian_mult_neighbor

bool	_tangent_is_dpk1_df

Private Attributes
const std::size_t	_jvar_max_size

JvarMap	_jvar_map

std::map< std::string, JvarMap >	_jvar_local_map

Detailed Description

template<bool is_ad>
class SCZMInterfaceKernelSmallStrainTempl< is_ad >

AD and non-AD shifted cohesive zone interface kernel for the small-strain formulation.

Definition at line 16 of file SCZMInterfaceKernelSmallStrain.h.

Constructor & Destructor Documentation

◆ SCZMInterfaceKernelSmallStrainTempl()

template<bool is_ad>

SCZMInterfaceKernelSmallStrainTempl< is_ad >::SCZMInterfaceKernelSmallStrainTempl ( const InputParameters & parameters )

Definition at line 92 of file SCZMInterfaceKernelSmallStrain.C.

  : SCZMInterfaceKernelBaseTempl<is_ad>(parameters),
    _stress(this->template getGenericMaterialPropertyByName<RankTwoTensor, is_ad>(
        this->_base_name + parameters.get<MaterialPropertyName>("stress"))),
    _stress_neighbor(this->template getGenericNeighborMaterialPropertyByName<RankTwoTensor, is_ad>(
        this->_base_name + parameters.get<MaterialPropertyName>("stress"))),
    _dtraction_djump_global(nullptr),
    _Jacobian_mult(nullptr),
    _Jacobian_mult_neighbor(nullptr),
    _tangent_is_dpk1_df(false),
    _directional_correction(parameters.get<bool>("directional_correction")),
    _volumetric_locking_correction(false)
{
  if constexpr (!is_ad)
  {
    _disp_var.resize(this->_ndisp);
    _vars.resize(this->_ndisp);
    for (const auto i : make_range(this->_ndisp))
    {
      _disp_var[i] = this->coupled("displacements", i);
      _vars[i] = this->getVar("displacements", i);
    }
 
    _dtraction_djump_global = &this->template getMaterialPropertyByName<RankTwoTensor>(
        this->_base_name + "dtraction_djump_global");
    _Jacobian_mult = &this->template getMaterialPropertyByName<RankFourTensor>(
        this->_base_name + parameters.get<MaterialPropertyName>("tangent"));
    _Jacobian_mult_neighbor = &this->template getNeighborMaterialPropertyByName<RankFourTensor>(
        this->_base_name + parameters.get<MaterialPropertyName>("tangent"));
    _volumetric_locking_correction = parameters.get<bool>("volumetric_locking_correction");
 
    const auto & tangent_name = parameters.get<MaterialPropertyName>("tangent");
    const auto & tangent_definition = parameters.get<MooseEnum>("tangent_definition");
    if (tangent_definition == "auto")
    {
      if (tangent_name == "Jacobian_mult")
        _tangent_is_dpk1_df = false;
      else if (tangent_name == "pk1_jacobian")
        _tangent_is_dpk1_df = true;
      else
        this->paramError("tangent_definition",
                         "Cannot infer the mathematical definition of custom tangent property '",
                         tangent_name,
                         "'. Set 'tangent_definition' to 'stress_wrt_strain' or "
                         "'pk1_wrt_deformation_gradient'.");
    }
    else
      _tangent_is_dpk1_df = tangent_definition == "pk1_wrt_deformation_gradient";
  }
}

Member Function Documentation

◆ calculateDirectionalCorrectionJacobian() [1/3]

template<bool is_ad>

Real SCZMInterfaceKernelSmallStrainTempl< is_ad >::calculateDirectionalCorrectionJacobian	(	unsigned int	ivar,
		unsigned int	jvar,
		Moose::DGJacobianType	type
	)		const

protected

◆ calculateDirectionalCorrectionJacobian() [2/3]

Real SCZMInterfaceKernelSmallStrainTempl< false >::calculateDirectionalCorrectionJacobian	(	unsigned int	ivar,
		unsigned int	jvar,
		Moose::DGJacobianType	type
	)		const

protected

Definition at line 250 of file SCZMInterfaceKernelSmallStrain.C.

{
  const auto true_normal =
      _shifted ? RealVectorValue(trueNormal()) : RealVectorValue(_normals[_qp]);
 
  const bool trial_on_element = type == Moose::ElementElement || type == Moose::NeighborElement;
  const auto grad_phi = trial_on_element ? _grad_phi[_j][_qp] : _grad_phi_neighbor[_j][_qp];
 
  const auto nt_tangent = _normals[_qp] - (true_normal * _normals[_qp]) * true_normal;
 
  const auto test = (type == Moose::ElementElement || type == Moose::ElementNeighbor)
                        ? _test[_i][_qp]
                        : _test_neighbor[_i][_qp];
 
  const auto & r4t = (type == Moose::ElementElement || type == Moose::ElementNeighbor)
                         ? (*_Jacobian_mult)[_qp]
                         : (*_Jacobian_mult_neighbor)[_qp];
 
  const Real origin_part = ElasticityTensorTools::elasticJacobian(
      r4t, ivar, jvar, nt_tangent * test /*transpose later (w^T n^T)*/, grad_phi /*B*/);
 
  const Real n0 = nt_tangent(0);
  const Real n1 = nt_tangent(1);
  const Real n2 = nt_tangent(2);
 
  const Real gp0 = grad_phi(0);
  const Real gp1 = grad_phi(1);
  const Real gp2 = grad_phi(2);
 
  const auto i = ivar;
  const auto k = jvar;
 
  const Real symmetric_part =
      ((r4t(i, 0, 0, k) * gp0 + r4t(i, 0, 1, k) * gp1 + r4t(i, 0, 2, k) * gp2) * n0 +
       (r4t(i, 1, 0, k) * gp0 + r4t(i, 1, 1, k) * gp1 + r4t(i, 1, 2, k) * gp2) * n1 +
       (r4t(i, 2, 0, k) * gp0 + r4t(i, 2, 1, k) * gp1 + r4t(i, 2, 2, k) * gp2) * n2) *
      test;
 
  // dP/dF acts on the full displacement gradient. A strain-based tangent instead acts on the
  // symmetric gradient, which contributes the transposed contraction as well.
  Real jacobian = _tangent_is_dpk1_df ? origin_part : (origin_part + symmetric_part) * 0.5;
 
  if (_volumetric_locking_correction)
  {
    const auto grad_op = gradOpForCoord(_coord_sys,
                                        k,
                                        grad_phi,
                                        trial_on_element ? _phi[_j][_qp] : _phi_neighbor[_j][_qp],
                                        _q_point[_qp]);
    const auto avg_grad_op = StabilizationUtils::elementAverage(
        [this, k, trial_on_element](unsigned int qp)
        {
          return gradOpForCoord(_coord_sys,
                                k,
                                trial_on_element ? _grad_phi[_j][qp] : _grad_phi_neighbor[_j][qp],
                                trial_on_element ? _phi[_j][qp] : _phi_neighbor[_j][qp],
                                _q_point[qp]);
        },
        _JxW,
        _coord);
    const Real volumetric_increment = (avg_grad_op.trace() - grad_op.trace()) / 3.0;
 
    for (const auto m : make_range(3))
      jacobian += (r4t(i, 0, m, m) * n0 + r4t(i, 1, m, m) * n1 + r4t(i, 2, m, m) * n2) * test *
                  volumetric_increment;
  }
 
  return jacobian;
}

◆ calculateDirectionalCorrectionJacobian() [3/3]

Real SCZMInterfaceKernelSmallStrainTempl< true >::calculateDirectionalCorrectionJacobian	(	unsigned int	,
		unsigned int	,
		Moose::DGJacobianType
	)		const

protected

Definition at line 393 of file SCZMInterfaceKernelSmallStrain.C.

{
  return 0;
}

◆ computeDResidualDDisplacement() [1/3]

template<bool is_ad>

Real SCZMInterfaceKernelSmallStrainTempl< is_ad >::computeDResidualDDisplacement	(	unsigned int	component_j,
		Moose::DGJacobianType	type
	)		const

protected

◆ computeDResidualDDisplacement() [2/3]

Real SCZMInterfaceKernelSmallStrainTempl< false >::computeDResidualDDisplacement	(	unsigned int	component_j,
		Moose::DGJacobianType	type
	)		const

protected

Definition at line 192 of file SCZMInterfaceKernelSmallStrain.C.

{
  const auto jacsd = (*_dtraction_djump_global)[this->_qp](this->_component, component_j);
  Real jac = jacsd;
 
  if (!_shifted)
  {
    switch (type)
    {
      case Moose::ElementElement: // Residual_sign -1  ddeltaU_ddisp sign -1;
        jac *= _test[_i][_qp] * _vars[component_j]->phiFace()[_j][_qp];
        break;
      case Moose::ElementNeighbor: // Residual_sign -1  ddeltaU_ddisp sign 1;
        jac *= -_test[_i][_qp] * _vars[component_j]->phiFaceNeighbor()[_j][_qp];
        break;
      case Moose::NeighborElement: // Residual_sign 1  ddeltaU_ddisp sign -1;
        jac *= -_test_neighbor[_i][_qp] * _vars[component_j]->phiFace()[_j][_qp];
        break;
      case Moose::NeighborNeighbor: // Residual_sign 1  ddeltaU_ddisp sign 1;
        jac *= _test_neighbor[_i][_qp] * _vars[component_j]->phiFaceNeighbor()[_j][_qp];
        break;
    }
    return jac;
  }
 
  const auto d = surrogateDistance();
  const auto true_normal = RealVectorValue(trueNormal());
  const auto true_normal_dot_surrogate_normal = true_normal * _normals[_qp];
 
  // Shifted derivative uses d(u + grad_u * d)/du = phiFace + gradPhiFace * d.
  switch (type)
  {
    case Moose::ElementElement: // Residual_sign -1  ddeltaU_ddisp sign -1;
      jac *= _test[_i][_qp] * (_vars[component_j]->phiFace()[_j][_qp] +
                               _vars[component_j]->gradPhiFace()[_j][_qp] * d);
      break;
    case Moose::ElementNeighbor: // Residual_sign -1  ddeltaU_ddisp sign 1;
      jac *= -_test[_i][_qp] * (_vars[component_j]->phiFaceNeighbor()[_j][_qp] +
                                _vars[component_j]->gradPhiFaceNeighbor()[_j][_qp] * d);
      break;
    case Moose::NeighborElement: // Residual_sign 1  ddeltaU_ddisp sign -1;
      jac *= -_test_neighbor[_i][_qp] * (_vars[component_j]->phiFace()[_j][_qp] +
                                         _vars[component_j]->gradPhiFace()[_j][_qp] * d);
      break;
    case Moose::NeighborNeighbor: // Residual_sign 1  ddeltaU_ddisp sign 1;
      jac *= _test_neighbor[_i][_qp] * (_vars[component_j]->phiFaceNeighbor()[_j][_qp] +
                                        _vars[component_j]->gradPhiFaceNeighbor()[_j][_qp] * d);
      break;
  }
 
  jac *= true_normal_dot_surrogate_normal; // Area correction
 
  return jac;
}

◆ computeDResidualDDisplacement() [3/3]

Real SCZMInterfaceKernelSmallStrainTempl< true >::computeDResidualDDisplacement	(	unsigned int	,
		Moose::DGJacobianType
	)		const

protected

Definition at line 184 of file SCZMInterfaceKernelSmallStrain.C.

{
  return 0;
}

◆ computeQpJacobian() [1/3]

Real SCZMInterfaceKernelSmallStrainTempl< false >::computeQpJacobian ( Moose::DGJacobianType type )

protected

Definition at line 330 of file SCZMInterfaceKernelSmallStrain.C.

{
  Real jacobian = computeDResidualDDisplacement(this->_component, type);
 
  if (_shifted && _directional_correction)
    switch (type)
    {
      case Moose::ElementElement:
        jacobian -= calculateDirectionalCorrectionJacobian(_component, _component, type);
        break;
      case Moose::NeighborNeighbor:
        jacobian += calculateDirectionalCorrectionJacobian(_component, _component, type);
        break;
      case Moose::ElementNeighbor:
      case Moose::NeighborElement:
        break;
    }
 
  return jacobian;
}

◆ computeQpJacobian() [2/3]

template<bool is_ad>

Real SCZMInterfaceKernelSmallStrainTempl< is_ad >::computeQpJacobian ( Moose::DGJacobianType type )

overrideprotected

◆ computeQpJacobian() [3/3]

Real SCZMInterfaceKernelSmallStrainTempl< true >::computeQpJacobian ( Moose::DGJacobianType )

protected

Definition at line 323 of file SCZMInterfaceKernelSmallStrain.C.

{
  return 0;
}

◆ computeQpOffDiagJacobian() [1/3]

Real SCZMInterfaceKernelSmallStrainTempl< false >::computeQpOffDiagJacobian	(	Moose::DGJacobianType	type,
		unsigned int	jvar
	)

protected

Definition at line 361 of file SCZMInterfaceKernelSmallStrain.C.

{
  if (this->getJvarMap()[jvar] < 0)
    return 0;
 
  Real jacobian = 0;
  for (const auto coupled_component : make_range(this->_ndisp))
    if (jvar == _disp_var[coupled_component])
      jacobian = computeDResidualDDisplacement(coupled_component, type);
 
  if (_shifted && _directional_correction)
    for (const auto coupled_component : make_range(_ndisp))
      if (jvar == _disp_var[coupled_component])
        switch (type)
        {
          case Moose::ElementElement:
            jacobian -= calculateDirectionalCorrectionJacobian(_component, coupled_component, type);
            break;
          case Moose::NeighborNeighbor:
            jacobian += calculateDirectionalCorrectionJacobian(_component, coupled_component, type);
            break;
          case Moose::ElementNeighbor:
          case Moose::NeighborElement:
            break;
        }
 
  return jacobian;
}

◆ computeQpOffDiagJacobian() [2/3]

template<bool is_ad>

Real SCZMInterfaceKernelSmallStrainTempl< is_ad >::computeQpOffDiagJacobian	(	Moose::DGJacobianType	type,
		unsigned int	jvar
	)

overrideprotected

◆ computeQpOffDiagJacobian() [3/3]

Real SCZMInterfaceKernelSmallStrainTempl< true >::computeQpOffDiagJacobian	(	Moose::DGJacobianType	,
		unsigned int
	)

protected

Definition at line 353 of file SCZMInterfaceKernelSmallStrain.C.

{
  return 0;
}

◆ computeQpResidual()

template<bool is_ad>

GenericReal< is_ad > SCZMInterfaceKernelSmallStrainTempl< is_ad >::computeQpResidual ( Moose::DGResidualType type )

overrideprotected

Definition at line 146 of file SCZMInterfaceKernelSmallStrain.C.

{
  if (!this->_shifted)
    return SCZMInterfaceKernelBaseTempl<is_ad>::computeQpResidual(type);
 
  const RealVectorValue true_normal(this->trueNormal());
  const Real true_normal_dot_surrogate_normal = true_normal * this->_normals[this->_qp];
 
  auto residual = SCZMInterfaceKernelBaseTempl<is_ad>::computeQpResidual(type);
  residual *= true_normal_dot_surrogate_normal;
 
  if (_directional_correction)
  {
    const auto stress = _stress[this->_qp].row(this->_component);
    const auto stress_neighbor = _stress_neighbor[this->_qp].row(this->_component);
    const auto normal_tangent =
        this->_normals[this->_qp] - true_normal_dot_surrogate_normal * true_normal;
 
    switch (type)
    {
      case Moose::Element:
        residual -= this->_test[this->_i][this->_qp] * (stress * normal_tangent);
        break;
 
      case Moose::Neighbor:
        residual += this->_test_neighbor[this->_i][this->_qp] * (stress_neighbor * normal_tangent);
        break;
 
      default:
        break;
    }
  }
 
  return residual;
}

◆ perform_shifted()

template<bool is_ad>

bool SCZMInterfaceKernelBaseTempl< is_ad >::perform_shifted ( ) const

inlineoverrideprotectedinherited

Whether to apply the shifted integration corrections.

Shifted integration is the default and intended mode for SBM simulations. It can be disabled only to provide a non-shifted baseline with the same interface kernel and cohesive-zone model, which isolates the effect of the shifted correction terms for verification and comparison.

Definition at line 33 of file SCZMInterfaceKernelBase.h.

33{ return _shifted; }

◆ validParams()

template<bool is_ad>

InputParameters SCZMInterfaceKernelSmallStrainTempl< is_ad >::validParams ( )

static

Definition at line 59 of file SCZMInterfaceKernelSmallStrain.C.

{
  InputParameters params = SCZMInterfaceKernelBaseTempl<is_ad>::validParams();
 
  params.addParam<bool>("directional_correction", true, "Add the directional correction terms.");
  params.addParam<MaterialPropertyName>(
      "stress", "stress", "Name of the stress tensor material property.");
  if constexpr (!is_ad)
  {
    params.addParam<MaterialPropertyName>(
        "tangent", "Jacobian_mult", "Name of the material Jacobian tensor property.");
    params.addParam<MooseEnum>(
        "tangent_definition",
        MooseEnum("auto stress_wrt_strain pk1_wrt_deformation_gradient", "auto"),
        "Mathematical definition of the tangent material property. 'auto' recognizes the standard "
        "Jacobian_mult property as d(stress)/d(strain) and pk1_jacobian as d(PK1)/d(F). Select "
        "'stress_wrt_strain' or 'pk1_wrt_deformation_gradient' explicitly for a custom tangent "
        "property; use the latter only when the property is known to be d(PK1)/d(F).");
    params.addParam<bool>(
        "volumetric_locking_correction",
        false,
        "Whether to apply volumetric locking correction to the directional "
        "correction Jacobian. This setting should be consistent with the volumetric "
        "locking correction used in the bulk finite element formulation to ensure "
        "the interface Jacobian is consistent with the bulk stress.");
  }
  params.addClassDescription(
      "Shifted CZM Interface kernel to use when using the Small Strain kinematic formulation.");
 
  return params;
}