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 "GapConductanceConstraint.h"
      11             : 
      12             : registerMooseObject("HeatTransferApp", GapConductanceConstraint);
      13             : 
      14             : InputParameters
      15         114 : GapConductanceConstraint::validParams()
      16             : {
      17         114 :   InputParameters params = ADMortarConstraint::validParams();
      18         114 :   params.addClassDescription(
      19             :       "Computes the residual and Jacobian contributions for the 'Lagrange Multiplier' "
      20             :       "implementation of the thermal contact problem. For more information, see the "
      21             :       "detailed description here: http://tinyurl.com/gmmhbe9");
      22         228 :   params.addRequiredParam<Real>("k", "Gap conductance");
      23         228 :   params.addParam<Real>("min_gap",
      24         228 :                         1e-6,
      25             :                         "The minimum gap distance allowed. This helps with preventing the heat "
      26             :                         "flux from going to infinity as the gap approaches zero.");
      27         228 :   params.addCoupledVar("displacements", "Displacement variables");
      28         114 :   return params;
      29           0 : }
      30             : 
      31          57 : GapConductanceConstraint::GapConductanceConstraint(const InputParameters & parameters)
      32             :   : ADMortarConstraint(parameters),
      33          57 :     _k(getParam<Real>("k")),
      34         114 :     _min_gap(getParam<Real>("min_gap")),
      35         114 :     _disp_name(parameters.getVecMooseType("displacements")),
      36          57 :     _n_disp(_disp_name.size()),
      37          57 :     _disp_secondary(_n_disp),
      38         114 :     _disp_primary(_n_disp)
      39             : {
      40         133 :   for (unsigned int i = 0; i < _n_disp; ++i)
      41             :   {
      42          76 :     auto & disp_var = _subproblem.getStandardVariable(_tid, _disp_name[i]);
      43          76 :     _disp_secondary[i] = &disp_var.adSln();
      44          76 :     _disp_primary[i] = &disp_var.adSlnNeighbor();
      45             :   }
      46          57 : }
      47             : 
      48             : ADReal
      49       97460 : GapConductanceConstraint::computeQpResidual(Moose::MortarType mortar_type)
      50             : {
      51       97460 :   switch (mortar_type)
      52             :   {
      53       38984 :     case Moose::MortarType::Primary:
      54       38984 :       return _lambda[_qp] * _test_primary[_i][_qp];
      55       38984 :     case Moose::MortarType::Secondary:
      56       77968 :       return -_lambda[_qp] * _test_secondary[_i][_qp];
      57       19492 :     case Moose::MortarType::Lower:
      58             :     {
      59             :       // we are creating an AD version of phys points primary and secondary here...
      60       19492 :       ADRealVectorValue ad_phys_points_primary = _phys_points_primary[_qp];
      61       19492 :       ADRealVectorValue ad_phys_points_secondary = _phys_points_secondary[_qp];
      62             : 
      63             :       // ...which uses the derivative vector of the primary and secondary displacements as
      64             :       // an approximation of the true phys points derivatives when the mesh is displacing
      65       19492 :       if (_displaced)
      66       21516 :         for (unsigned int i = 0; i < _n_disp; ++i)
      67             :         {
      68       14344 :           ad_phys_points_primary(i).derivatives() = (*_disp_primary[i])[_qp].derivatives();
      69       14344 :           ad_phys_points_secondary(i).derivatives() = (*_disp_secondary[i])[_qp].derivatives();
      70             :         }
      71             : 
      72             :       auto l =
      73       19492 :           std::max((ad_phys_points_primary - ad_phys_points_secondary) * _normals[_qp], _min_gap);
      74       77968 :       return (_lambda[_qp] - _k * (_u_primary[_qp] - _u_secondary[_qp]) / l) * _test[_i][_qp];
      75             :     }
      76             : 
      77           0 :     default:
      78           0 :       return 0;
      79             :   }
      80             : }