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 "PeriodicSegmentalConstraint.h"
      11             : 
      12             : registerMooseObject("MooseApp", PeriodicSegmentalConstraint);
      13             : 
      14             : InputParameters
      15       14355 : PeriodicSegmentalConstraint::validParams()
      16             : {
      17       14355 :   InputParameters params = MortarScalarBase::validParams();
      18       14355 :   params.addClassDescription(
      19             :       "PeriodicSegmentalConstraint enforces macro-micro periodic conditions between "
      20             :       "secondary and primary sides of a mortar interface using Lagrange multipliers."
      21             :       "Must be used alongside EqualValueConstraint.");
      22       14355 :   params.renameCoupledVar("scalar_variable", "epsilon", "Primary coupled scalar variable");
      23       14355 :   params.addRequiredCoupledVar("sigma", "Controlled scalar averaging variable");
      24             : 
      25       14355 :   return params;
      26           0 : }
      27             : 
      28          45 : PeriodicSegmentalConstraint::PeriodicSegmentalConstraint(const InputParameters & parameters)
      29             :   : DerivativeMaterialInterface<MortarScalarBase>(parameters),
      30          45 :     _kappa_aux_ptr(getScalarVar("sigma", 0)),
      31          45 :     _ka_order(_kappa_aux_ptr->order()),
      32          90 :     _kappa_aux(coupledScalarValue("sigma"))
      33             : {
      34          45 :   if (_kappa_aux_ptr->kind() != Moose::VarKindType::VAR_AUXILIARY)
      35           0 :     paramError("sigma",
      36             :                "Must assign auxiliary scalar variable to sigma, rather than nonlinear variable");
      37          45 : }
      38             : 
      39             : Real
      40     1087152 : PeriodicSegmentalConstraint::computeQpResidual(const Moose::MortarType mortar_type)
      41             : {
      42     1087152 :   RealVectorValue dx(_phys_points_primary[_qp] - _phys_points_secondary[_qp]);
      43     1087152 :   RealVectorValue kappa_vec(_kappa[0], 0, 0);
      44     1087152 :   if (_k_order == 2)
      45       34800 :     kappa_vec(1) = _kappa[1];
      46     1052352 :   else if (_k_order == 3)
      47             :   {
      48     1052352 :     kappa_vec(1) = _kappa[1];
      49     1052352 :     kappa_vec(2) = _kappa[2];
      50             :   }
      51     1087152 :   Real r = -(kappa_vec * dx);
      52             : 
      53     1087152 :   switch (mortar_type)
      54             :   {
      55       76056 :     case Moose::MortarType::Lower:
      56       76056 :       r *= _test[_i][_qp];
      57       76056 :       break;
      58     1011096 :     default:
      59     1011096 :       return 0;
      60             :   }
      61       76056 :   return r;
      62             : }
      63             : 
      64             : Real
      65       57624 : PeriodicSegmentalConstraint::computeScalarQpResidual()
      66             : {
      67             :   // Stability/penalty term for residual of scalar variable
      68       57624 :   RealVectorValue dx(_phys_points_primary[_qp] - _phys_points_secondary[_qp]);
      69       57624 :   Real r = -dx(_h) * _lambda[_qp];
      70             : 
      71       57624 :   RealVectorValue kappa_aux_vec(_kappa_aux[0], 0, 0);
      72       57624 :   if (_k_order == 2)
      73             :   {
      74        3192 :     kappa_aux_vec(1) = _kappa_aux[1];
      75             :   }
      76       54432 :   else if (_k_order == 3)
      77             :   {
      78       54432 :     kappa_aux_vec(1) = _kappa_aux[1];
      79       54432 :     kappa_aux_vec(2) = _kappa_aux[2];
      80             :   }
      81             : 
      82       57624 :   r -= dx(_h) * (kappa_aux_vec * _normals[_qp]);
      83             : 
      84       57624 :   return r;
      85             : }
      86             : 
      87             : Real
      88     2136864 : PeriodicSegmentalConstraint::computeQpOffDiagJacobianScalar(const Moose::MortarType mortar_type,
      89             :                                                             const unsigned int svar_num)
      90             : {
      91     2136864 :   if (svar_num != _kappa_var)
      92           0 :     return 0;
      93             : 
      94             :   // Stability/penalty term for Jacobian
      95     2136864 :   RealVectorValue dx(_phys_points_primary[_qp] - _phys_points_secondary[_qp]);
      96     2136864 :   Real jac = -dx(_h);
      97             : 
      98     2136864 :   switch (mortar_type)
      99             :   {
     100      148368 :     case Moose::MortarType::Lower: // Residual_sign -1  ddeltaU_ddisp sign 1;
     101      148368 :       jac *= _test[_i][_qp];
     102      148368 :       break;
     103     1988496 :     default:
     104     1988496 :       return 0;
     105             :   }
     106      148368 :   return jac;
     107             : }
     108             : 
     109             : Real
     110     2468280 : PeriodicSegmentalConstraint::computeScalarQpOffDiagJacobian(const Moose::MortarType mortar_type,
     111             :                                                             const unsigned int jvar_num)
     112             : {
     113             :   // Test if jvar is the ID of the primary variables and not some other random variable
     114     2468280 :   switch (mortar_type)
     115             :   {
     116      479784 :     case Moose::MortarType::Lower:
     117      479784 :       if (!_var || _var->number() != jvar_num)
     118      331416 :         return 0;
     119      148368 :       break;
     120     1988496 :     default:
     121     1988496 :       return 0;
     122             :   }
     123             : 
     124             :   // Stability/penalty term for Jacobian
     125      148368 :   RealVectorValue dx(_phys_points_primary[_qp] - _phys_points_secondary[_qp]);
     126      148368 :   Real jac = -dx(_h);
     127             : 
     128      148368 :   switch (mortar_type)
     129             :   {
     130      148368 :     case Moose::MortarType::Lower:
     131      148368 :       jac *= (*_phi)[_j][_qp];
     132      148368 :       break;
     133           0 :     default:
     134           0 :       return 0;
     135             :   }
     136      148368 :   return jac;
     137             : }