Line data    Source code

       1             : //* This file is part of the MOOSE framework
       2             : //* https://mooseframework.inl.gov
       3             : //*
       4             : //* All rights reserved, see COPYRIGHT for full restrictions
       5             : //* https://github.com/idaholab/moose/blob/master/COPYRIGHT
       6             : //*
       7             : //* Licensed under LGPL 2.1, please see LICENSE for details
       8             : //* https://www.gnu.org/licenses/lgpl-2.1.html
       9             : 
      10             : #include "MortarUserObjectAux.h"
      11             : 
      12             : // supported user objects
      13             : #include "WeightedGapUserObject.h"
      14             : #include "PenaltyWeightedGapUserObject.h"
      15             : #include "WeightedVelocitiesUserObject.h"
      16             : #include "PenaltyFrictionUserObject.h"
      17             : 
      18             : registerMooseObject("ContactApp", MortarUserObjectAux);
      19             : registerMooseObjectRenamed("ContactApp",
      20             :                            PenaltyMortarUserObjectAux,
      21             :                            "04/01/2026 00:00",
      22             :                            MortarUserObjectAux);
      23             : 
      24             : const MooseEnum MortarUserObjectAux::_contact_quantities(
      25             :     "normal_pressure accumulated_slip_one "
      26             :     "tangential_pressure_one tangential_velocity_one accumulated_slip_two "
      27             :     "tangential_pressure_two tangential_velocity_two normal_gap "
      28             :     "normal_lm delta_tangential_lm_one delta_tangential_lm_two active_set");
      29             : 
      30             : InputParameters
      31        1831 : MortarUserObjectAux::validParams()
      32             : {
      33        1831 :   InputParameters params = AuxKernel::validParams();
      34        1831 :   params.addClassDescription(
      35             :       "Populates an auxiliary variable with a contact quantities from penalty mortar contact.");
      36        3662 :   params.addRequiredParam<MooseEnum>(
      37             :       "contact_quantity",
      38             :       _contact_quantities,
      39             :       "The desired contact quantity to output as an auxiliary variable.");
      40        3662 :   params.addRequiredParam<UserObjectName>(
      41             :       "user_object",
      42             :       "The penalty mortar user object to get values from.  Note that the user object "
      43             :       "must implement the corresponding getter function.");
      44        5493 :   params.set<ExecFlagEnum>("execute_on") = {EXEC_TIMESTEP_END};
      45        1831 :   params.suppressParameter<ExecFlagEnum>("execute_on");
      46        1831 :   return params;
      47        1831 : }
      48             : 
      49         979 : MortarUserObjectAux::MortarUserObjectAux(const InputParameters & parameters)
      50             :   : AuxKernel(parameters),
      51         979 :     _contact_quantity(getParam<MooseEnum>("contact_quantity").getEnum<ContactQuantityEnum>()),
      52         979 :     _user_object(getUserObject<UserObject>("user_object")),
      53         979 :     _wguo(dynamic_cast<const WeightedGapUserObject *>(&_user_object)),
      54         979 :     _pwguo(dynamic_cast<const PenaltyWeightedGapUserObject *>(&_user_object)),
      55         979 :     _wvuo(dynamic_cast<const WeightedVelocitiesUserObject *>(&_user_object)),
      56         979 :     _pfuo(dynamic_cast<const PenaltyFrictionUserObject *>(&_user_object)),
      57       12727 :     _outputs({
      58             :         {ContactQuantityEnum::NORMAL_PRESSURE,
      59             :          {"WeightedGapUserObject",
      60         979 :           _wguo,
      61      147115 :           [&]() { return _wguo->getNormalContactPressure(_current_node); }}},
      62             : 
      63             :         {ContactQuantityEnum::NORMAL_GAP,
      64      140311 :          {"WeightedGapUserObject", _wguo, [&]() { return _wguo->getNormalGap(_current_node); }}},
      65             : 
      66             :         {ContactQuantityEnum::FRICTIONAL_PRESSURE_ONE,
      67             :          {"PenaltyFrictionUserObject",
      68         979 :           _pfuo,
      69      128851 :           [&]() { return _pfuo->getFrictionalContactPressure(_current_node, 0); }}},
      70             : 
      71             :         {ContactQuantityEnum::ACCUMULATED_SLIP_ONE,
      72             :          {"PenaltyFrictionUserObject",
      73             :           _pfuo,
      74      128851 :           [&]() { return _pfuo->getAccumulatedSlip(_current_node, 0); }}},
      75             : 
      76             :         {ContactQuantityEnum::TANGENTIAL_VELOCITY_ONE,
      77             :          {"WeightedVelocitiesUserObject",
      78         979 :           _wvuo,
      79      126595 :           [&]() { return _wvuo->getTangentialVelocity(_current_node, 0); }}},
      80             : 
      81             :         {ContactQuantityEnum::FRICTIONAL_PRESSURE_TWO,
      82             :          {"PenaltyFrictionUserObject",
      83             :           _pfuo,
      84        3235 :           [&]() { return _pfuo->getFrictionalContactPressure(_current_node, 1); }}},
      85             : 
      86             :         {ContactQuantityEnum::ACCUMULATED_SLIP_TWO,
      87             :          {"PenaltyFrictionUserObject",
      88             :           _pfuo,
      89        3235 :           [&]() { return _pfuo->getAccumulatedSlip(_current_node, 1); }}},
      90             : 
      91             :         {ContactQuantityEnum::TANGENTIAL_VELOCITY_TWO,
      92             :          {"WeightedVelocitiesUserObject",
      93             :           _wvuo,
      94         979 :           [&]() { return _wvuo->getTangentialVelocity(_current_node, 1); }}},
      95             : 
      96             :         {ContactQuantityEnum::NORMAL_LM,
      97             :          {"PenaltyWeightedGapUserObject",
      98         979 :           _pwguo,
      99        1789 :           [&]() { return _pwguo->getNormalLagrangeMultiplier(_current_node); }}},
     100             : 
     101             :         {ContactQuantityEnum::DELTA_TANGENTIAL_LM_ONE,
     102             :          {"PenaltyFrictionUserObject",
     103             :           _wvuo,
     104         979 :           [&]() { return _pfuo->getDeltaTangentialLagrangeMultiplier(_current_node, 0); }}},
     105             : 
     106             :         {ContactQuantityEnum::DELTA_TANGENTIAL_LM_TWO,
     107             :          {"PenaltyFrictionUserObject",
     108             :           _wvuo,
     109         979 :           [&]() { return _pfuo->getDeltaTangentialLagrangeMultiplier(_current_node, 1); }}},
     110             : 
     111             :         {ContactQuantityEnum::ACTIVE_SET,
     112             :          {"PenaltyWeightedGapUserObject",
     113             :           _wvuo,
     114         979 :           [&]() { return _pwguo->getActiveSetState(_current_node) ? 1.0 : 0.0; }}}
     115             :         // end outputs list
     116         979 :     })
     117             : {
     118         979 :   if (!isNodal())
     119           0 :     mooseError("This auxiliary kernel requires nodal variables to obtain contact pressure values");
     120             : 
     121             :   // error check
     122         979 :   const auto it = _outputs.find(_contact_quantity);
     123         979 :   if (it == _outputs.end())
     124           0 :     mooseError("Internal error: Contact quantity request in MortarUserObjectAux is not "
     125             :                "recognized.");
     126         979 :   if (!std::get<1>(it->second))
     127          44 :     paramError("user_object",
     128             :                "The '",
     129          22 :                _contact_quantities.getNames()[static_cast<int>(it->first)],
     130             :                "' quantity is only provided by a '",
     131             :                std::get<0>(it->second),
     132             :                "' or derived object.");
     133       12705 : }
     134             : 
     135             : Real
     136      672150 : MortarUserObjectAux::computeValue()
     137             : {
     138             :   // execute functional to retrieve selected quantity
     139      672150 :   return std::get<2>(_outputs[_contact_quantity])();
     140             : }