PenaltySimpleCohesiveZoneModel

Description

The PenaltySimpleCohesiveZoneModel is an intermediate object between mortar mechanical contact and mortar cohesive zone models. It can apply penalty mortar normal and tangential contact forces and is intended to be used as a parent class for more advanced cohesive zone models, such as BilinearMixedModeCohesiveZoneModel.

Input Parameters

disp_xThe x displacement variable
C++ Type:std::vector<VariableName>
Unit:(no unit assumed)
Controllable:No
Description:The x displacement variable
disp_yThe y displacement variable
C++ Type:std::vector<VariableName>
Unit:(no unit assumed)
Controllable:No
Description:The y displacement variable
friction_coefficientThe friction coefficient ruling Coulomb friction equations.
C++ Type:double
Unit:(no unit assumed)
Controllable:No
Description:The friction coefficient ruling Coulomb friction equations.
penaltyThe penalty factor
C++ Type:double
Unit:(no unit assumed)
Controllable:No
Description:The penalty factor
primary_boundaryThe name of the primary boundary sideset.
C++ Type:BoundaryName
Unit:(no unit assumed)
Controllable:No
Description:The name of the primary boundary sideset.
primary_subdomainThe name of the primary subdomain.
C++ Type:SubdomainName
Unit:(no unit assumed)
Controllable:No
Description:The name of the primary subdomain.
secondary_boundaryThe name of the secondary boundary sideset.
C++ Type:BoundaryName
Unit:(no unit assumed)
Controllable:No
Description:The name of the secondary boundary sideset.
secondary_subdomainThe name of the secondary subdomain.
C++ Type:SubdomainName
Unit:(no unit assumed)
Controllable:No
Description:The name of the secondary subdomain.
secondary_variablePrimal variable on secondary surface.
C++ Type:VariableName
Unit:(no unit assumed)
Controllable:No
Description:Primal variable on secondary surface.

Required Parameters

adaptivity_penalty_normalSIMPLEThe augmented Lagrange update strategy used on the normal penalty coefficient.
Default:SIMPLE
C++ Type:MooseEnum
Unit:(no unit assumed)
Options:SIMPLE, BUSSETTA
Controllable:No
Description:The augmented Lagrange update strategy used on the normal penalty coefficient.
aux_lmAuxiliary variable that is utilized together with the penalty approach to interpolate the resulting contact tractions using dual bases.
C++ Type:std::vector<VariableName>
Unit:(no unit assumed)
Controllable:No
Description:Auxiliary variable that is utilized together with the penalty approach to interpolate the resulting contact tractions using dual bases.
correct_edge_droppingFalseWhether to enable correct edge dropping treatment for mortar constraints. When disabled any Lagrange Multiplier degree of freedom on a secondary element without full primary contributions will be set (strongly) to 0.
Default:False
C++ Type:bool
Unit:(no unit assumed)
Controllable:No
Description:Whether to enable correct edge dropping treatment for mortar constraints. When disabled any Lagrange Multiplier degree of freedom on a secondary element without full primary contributions will be set (strongly) to 0.
debug_meshFalseWhether this constraint is going to enable mortar segment mesh debug information. An exodusfile will be generated if the user sets this flag to true
Default:False
C++ Type:bool
Unit:(no unit assumed)
Controllable:No
Description:Whether this constraint is going to enable mortar segment mesh debug information. An exodusfile will be generated if the user sets this flag to true
disp_zThe z displacement variable
C++ Type:std::vector<VariableName>
Unit:(no unit assumed)
Controllable:No
Description:The z displacement variable
ghost_higher_d_neighborsFalseWhether we should ghost higher-dimensional neighbors. This is necessary when we are doing second order mortar with finite volume primal variables, because in order for the method to be second order we must use cell gradients, which couples in the neighbor cells.
Default:False
C++ Type:bool
Unit:(no unit assumed)
Controllable:No
Description:Whether we should ghost higher-dimensional neighbors. This is necessary when we are doing second order mortar with finite volume primal variables, because in order for the method to be second order we must use cell gradients, which couples in the neighbor cells.
ghost_point_neighborsFalseWhether we should ghost point neighbors of secondary face elements, and consequently also their mortar interface couples.
Default:False
C++ Type:bool
Unit:(no unit assumed)
Controllable:No
Description:Whether we should ghost point neighbors of secondary face elements, and consequently also their mortar interface couples.
interpolate_normalsFalseWhether to interpolate the nodal normals (e.g. classic idea of evaluating field at quadrature points). If this is set to false, then non-interpolated nodal normals will be used, and then the _normals member should be indexed with _i instead of _qp
Default:False
C++ Type:bool
Unit:(no unit assumed)
Controllable:No
Description:Whether to interpolate the nodal normals (e.g. classic idea of evaluating field at quadrature points). If this is set to false, then non-interpolated nodal normals will be used, and then the _normals member should be indexed with _i instead of _qp
minimum_projection_angle40Parameter to control which angle (in degrees) is admissible for the creation of mortar segments. If set to a value close to zero, very oblique projections are allowed, which can result in mortar segments solving physics not meaningfully, and overprojection of primary nodes onto the mortar segment mesh in extreme cases. This parameter is mostly intended for mortar mesh debugging purposes in two dimensions.
Default:40
C++ Type:double
Unit:(no unit assumed)
Controllable:No
Description:Parameter to control which angle (in degrees) is admissible for the creation of mortar segments. If set to a value close to zero, very oblique projections are allowed, which can result in mortar segments solving physics not meaningfully, and overprojection of primary nodes onto the mortar segment mesh in extreme cases. This parameter is mostly intended for mortar mesh debugging purposes in two dimensions.
penalty_frictionThe penalty factor for frictional interaction. If not provide, the normal penalty factor is also used for the frictional problem.
C++ Type:double
Unit:(no unit assumed)
Controllable:No
Description:The penalty factor for frictional interaction. If not provide, the normal penalty factor is also used for the frictional problem.
periodicFalseWhether this constraint is going to be used to enforce a periodic condition. This has the effect of changing the normals vector for projection from outward to inward facing
Default:False
C++ Type:bool
Unit:(no unit assumed)
Controllable:No
Description:Whether this constraint is going to be used to enforce a periodic condition. This has the effect of changing the normals vector for projection from outward to inward facing
primary_variablePrimal variable on primary surface. If this parameter is not provided then the primary variable will be initialized to the secondary variable
C++ Type:VariableName
Unit:(no unit assumed)
Controllable:No
Description:Primal variable on primary surface. If this parameter is not provided then the primary variable will be initialized to the secondary variable
prop_getter_suffixAn optional suffix parameter that can be appended to any attempt to retrieve/get material properties. The suffix will be prepended with a '_' character.
C++ Type:MaterialPropertyName
Unit:(no unit assumed)
Controllable:No
Description:An optional suffix parameter that can be appended to any attempt to retrieve/get material properties. The suffix will be prepended with a '_' character.
use_interpolated_stateFalseFor the old and older state use projected material properties interpolated at the quadrature points. To set up projection use the ProjectedStatefulMaterialStorageAction.
Default:False
C++ Type:bool
Unit:(no unit assumed)
Controllable:No
Description:For the old and older state use projected material properties interpolated at the quadrature points. To set up projection use the ProjectedStatefulMaterialStorageAction.
use_physical_gapFalseWhether to use the physical normal gap (not scaled by mortar integration) and normalize the penalty coefficient with a representative lower-dimensional volume assigned to the node in the contacting boundary. This parameter is defaulted to 'true' in the contact action.
Default:False
C++ Type:bool
Unit:(no unit assumed)
Controllable:No
Description:Whether to use the physical normal gap (not scaled by mortar integration) and normalize the penalty coefficient with a representative lower-dimensional volume assigned to the node in the contacting boundary. This parameter is defaulted to 'true' in the contact action.

Optional Parameters

allow_duplicate_execution_on_initialFalseIn the case where this UserObject is depended upon by an initial condition, allow it to be executed twice during the initial setup (once before the IC and again after mesh adaptivity (if applicable).
Default:False
C++ Type:bool
Unit:(no unit assumed)
Controllable:No
Description:In the case where this UserObject is depended upon by an initial condition, allow it to be executed twice during the initial setup (once before the IC and again after mesh adaptivity (if applicable).
control_tagsAdds user-defined labels for accessing object parameters via control logic.
C++ Type:std::vector<std::string>
Unit:(no unit assumed)
Controllable:No
Description:Adds user-defined labels for accessing object parameters via control logic.
enableTrueSet the enabled status of the MooseObject.
Default:True
C++ Type:bool
Unit:(no unit assumed)
Controllable:Yes
Description:Set the enabled status of the MooseObject.
execution_order_group0Execution order groups are executed in increasing order (e.g., the lowest number is executed first). Note that negative group numbers may be used to execute groups before the default (0) group. Please refer to the user object documentation for ordering of user object execution within a group.
Default:0
C++ Type:int
Unit:(no unit assumed)
Controllable:No
Description:Execution order groups are executed in increasing order (e.g., the lowest number is executed first). Note that negative group numbers may be used to execute groups before the default (0) group. Please refer to the user object documentation for ordering of user object execution within a group.
force_postauxFalseForces the UserObject to be executed in POSTAUX
Default:False
C++ Type:bool
Unit:(no unit assumed)
Controllable:No
Description:Forces the UserObject to be executed in POSTAUX
force_preauxFalseForces the UserObject to be executed in PREAUX
Default:False
C++ Type:bool
Unit:(no unit assumed)
Controllable:No
Description:Forces the UserObject to be executed in PREAUX
force_preicFalseForces the UserObject to be executed in PREIC during initial setup
Default:False
C++ Type:bool
Unit:(no unit assumed)
Controllable:No
Description:Forces the UserObject to be executed in PREIC during initial setup
use_displaced_meshTrueWhether or not this object should use the displaced mesh for computation. Note that in the case this is true but no displacements are provided in the Mesh block the undisplaced mesh will still be used.
Default:True
C++ Type:bool
Unit:(no unit assumed)
Controllable:No
Description:Whether or not this object should use the displaced mesh for computation. Note that in the case this is true but no displacements are provided in the Mesh block the undisplaced mesh will still be used.

Advanced Parameters

max_penalty_multiplier1000Maximum multiplier applied to penalty factors when adaptivity is used in an augmented Lagrange setting. The penalty factor supplied by the user is used as a reference.
Default:1000
C++ Type:double
Unit:(no unit assumed)
Controllable:No
Description:Maximum multiplier applied to penalty factors when adaptivity is used in an augmented Lagrange setting. The penalty factor supplied by the user is used as a reference.
penalty_multiplier1The penalty growth factor between augmented Lagrange iterations if weighted gap does not get closed fast enough. For frictional simulations, values smaller than 100 are recommended, e.g. 5.
Default:1
C++ Type:double
Unit:(no unit assumed)
Controllable:No
Description:The penalty growth factor between augmented Lagrange iterations if weighted gap does not get closed fast enough. For frictional simulations, values smaller than 100 are recommended, e.g. 5.
penetration_toleranceAcceptable penetration distance at which augmented Lagrange iterations can be stopped
C++ Type:double
Unit:(no unit assumed)
Controllable:No
Description:Acceptable penetration distance at which augmented Lagrange iterations can be stopped

Augmented Lagrange Parameters

Child Objects

(modules/contact/include/userobjects/BilinearMixedModeCohesiveZoneModel.h)

(modules/contact/include/userobjects/BilinearMixedModeCohesiveZoneModel.h)

// 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 "PenaltySimpleCohesiveZoneModel.h"
#include "TwoVector.h"

/**
 * User object that interface pressure resulting from a simple traction separation law.
 */
class BilinearMixedModeCohesiveZoneModel : virtual public PenaltyWeightedGapUserObject,
                                           virtual public WeightedVelocitiesUserObject,
                                           virtual public PenaltySimpleCohesiveZoneModel
{
public:
  static InputParameters validParams();

  BilinearMixedModeCohesiveZoneModel(const InputParameters & parameters);

  virtual const ADVariableValue & czmGlobalTraction(unsigned int i) const;

  virtual void initialize() override;
  virtual void finalize() override;
  virtual void reinit() override;
  virtual void timestepSetup() override;

  // Getters for analysis output
  Real getModeMixityRatio(const Node * const node) const;
  Real getCohesiveDamage(const Node * const node) const;
  Real getLocalDisplacementNormal(const Node * const node) const;
  Real getLocalDisplacementTangential(const Node * const node) const;

protected:
  virtual void computeQpProperties() override;
  virtual void computeQpIProperties() override;

  virtual bool constrainedByOwner() const override { return false; }

  // Compute CZM kinematics.
  virtual void prepareJumpKinematicQuantities() override;
  virtual void computeFandR(const Node * const node) override;

  // @{
  // Compute CZM bilinear traction law.
  virtual void computeModeMixity(const Node * const node);
  virtual void computeCriticalDisplacementJump(const Node * const node);
  virtual void computeFinalDisplacementJump(const Node * const node);
  virtual void computeEffectiveDisplacementJump(const Node * const node);
  virtual void computeDamage(const Node * const node);
  // @}

  /// Encapsulate the CZM constitutive behavior.
  virtual void computeBilinearMixedModeTraction(const Node * const node) override;

  /// Compute global traction for mortar application
  virtual void computeGlobalTraction(const Node * const node) override;

  /// Normalize mortar quantities (remove mortar integral scaling)
  template <class T>
  T normalizeQuantity(const std::unordered_map<const DofObject *, T> & map,
                      const Node * const node);

  /// Number of displacement components
  const unsigned int _ndisp;

  /// Coupled displacement gradients
  std::vector<const GenericVariableGradient<true> *> _grad_disp;

  /// Coupled displacement and neighbor displacement gradient
  std::vector<const GenericVariableGradient<true> *> _grad_disp_neighbor;

  /// *** Kinematics/displacement jump quantities ***
  /// Map from degree of freedom to rotation matrix
  std::unordered_map<const DofObject *, ADRankTwoTensor> _dof_to_rotation_matrix;

  /// Map from degree of freedom to local displacement jump
  std::unordered_map<const DofObject *, ADRealVectorValue> _dof_to_interface_displacement_jump;

  /// Deformation gradient for interpolation
  ADRankTwoTensor _F_interpolation;

  /// Deformation gradient for interpolation of the neighbor projection
  ADRankTwoTensor _F_neighbor_interpolation;

  /// Map from degree of freedom to secondary, interpolated deformation gradient tensor
  std::unordered_map<const DofObject *, ADRankTwoTensor> _dof_to_F;

  /// Map from degree of freedom to neighbor, interpolated deformation gradient tensor
  std::unordered_map<const DofObject *, ADRankTwoTensor> _dof_to_F_neighbor;

  /// Map from degree of freedom to interface deformation gradient tensor
  std::unordered_map<const DofObject *, ADRankTwoTensor> _dof_to_interface_F;

  /// Map from degree of freedom to interface rotation tensor
  std::unordered_map<const DofObject *, ADRankTwoTensor> _dof_to_interface_R;

  /// Map from degree of freedom to mode mixity ratio (AD needed?)
  std::unordered_map<const DofObject *, ADReal> _dof_to_mode_mixity_ratio;

  /// The normal strength material property
  const MaterialProperty<Real> & _normal_strength;

  /// The shear strength material property
  const MaterialProperty<Real> & _shear_strength;

  /// Fracture parameter mode I
  const MaterialProperty<Real> & _GI_c;

  /// Fracture parameter mode II
  const MaterialProperty<Real> & _GII_c;

  /// Interpolated value of normal_strength
  ADReal _normal_strength_interpolation;

  /// Interpolated value of shear_strength
  ADReal _shear_strength_interpolation;

  /// Interpolated value of fracture paramter mode I
  ADReal _GI_c_interpolation;

  /// Interpolated value of fracture paramter mode II
  ADReal _GII_c_interpolation;

  // Penalty stiffness for bilinear traction model
  const Real _penalty_stiffness_czm;

  /// Mixed-mode propagation criterion
  enum class MixedModeCriterion
  {
    POWER_LAW,
    BK
  } _mix_mode_criterion;

  /// Power law parameter for bilinear traction model
  const Real _power_law_parameter;

  /// Viscosity for damage model
  const Real _viscosity;

  /// Parameter for the regularization of the Macaulay bracket
  const Real _regularization_alpha;

  /// The global traction
  std::vector<ADVariableValue> _czm_interpolated_traction;

  // @{
  // Strength material properties at the nodes
  std::unordered_map<const DofObject *, ADReal> _dof_to_normal_strength;
  std::unordered_map<const DofObject *, ADReal> _dof_to_shear_strength;
  // @}

  // @{
  // Fracture properties at the nodes
  std::unordered_map<const DofObject *, ADReal> _dof_to_GI_c;
  std::unordered_map<const DofObject *, ADReal> _dof_to_GII_c;
  // @}

  // @{
  // The parameters in the damage evolution law: Maps node to damage
  std::unordered_map<const DofObject *, ADReal> _dof_to_delta_initial;
  std::unordered_map<const DofObject *, ADReal> _dof_to_delta_final;
  std::unordered_map<const DofObject *, ADReal> _dof_to_delta_max;
  std::unordered_map<const DofObject *, std::pair<ADReal, Real>> _dof_to_damage;
  // @}

  /// Total Lagrangian stress to be applied on CZM interface
  std::unordered_map<const DofObject *, ADRealVectorValue> _dof_to_czm_traction;

  std::unordered_map<const DofObject *, ADRealVectorValue> _dof_to_displacement_jump;
};

Description
Input Parameters
Child Objects