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 "ADPenaltyVelocityContinuityNewmarkBeta.h"
      11             : #include "InertialForce.h"
      12             : 
      13             : registerMooseObject("FsiApp", ADPenaltyVelocityContinuityNewmarkBeta);
      14             : 
      15             : InputParameters
      16          15 : ADPenaltyVelocityContinuityNewmarkBeta::validParams()
      17             : {
      18          15 :   InputParameters params = ADPenaltyVelocityContinuity::validParams();
      19          15 :   params.addClassDescription(
      20             :       "Enforces continuity of flux and continuity of solution via penalty across an interface with "
      21             :       "the solid velocity computed via the Newmark-Beta method.");
      22          30 :   params.setDocString(
      23             :       "solid_velocities",
      24             :       "solid velocity variables whose previous timestep values we will use to compute the current "
      25             :       "solid velocities using the Newmark-Beta time integration method");
      26          30 :   params.addRequiredCoupledVar(
      27             :       "solid_accelerations",
      28             :       "solid acceleration variables whose previous timestep values we will use to compute the "
      29             :       "current solid accelerations using the Newmark-Beta time integration method");
      30          30 :   params.addRequiredParam<Real>("beta", "beta parameter for Newmark-Beta time integration");
      31          30 :   params.addRequiredParam<Real>("gamma", "gamma parameter for Newmark-Beta time integration");
      32          15 :   return params;
      33           0 : }
      34             : 
      35           8 : ADPenaltyVelocityContinuityNewmarkBeta::ADPenaltyVelocityContinuityNewmarkBeta(
      36           8 :     const InputParameters & parameters)
      37             :   : ADPenaltyVelocityContinuity(parameters),
      38          16 :     _beta(getParam<Real>("beta")),
      39          24 :     _gamma(getParam<Real>("gamma"))
      40             : {
      41          16 :   _solid_velocities_old.resize(coupledComponents("solid_velocities"));
      42          24 :   for (const auto i : index_range(_solid_velocities_old))
      43          16 :     _solid_velocities_old[i] = &coupledValueOld("solid_velocities", i);
      44             : 
      45          16 :   _solid_accelerations_old.resize(coupledComponents("solid_accelerations"));
      46          24 :   for (const auto i : index_range(_solid_accelerations_old))
      47          16 :     _solid_accelerations_old[i] = &coupledValueOld("solid_accelerations", i);
      48             : 
      49           8 :   if (_solid_accelerations_old.size() != _solid_velocities_old.size())
      50           0 :     paramError("solid_velocities",
      51             :                "'solid_velocities' and 'solid_accelerations' must be the same length!");
      52             : 
      53           8 :   _displacement_values.resize(_displacements.size());
      54           8 :   _displacement_values_old.resize(_displacements.size());
      55          24 :   for (const auto i : index_range(_displacement_values))
      56             :   {
      57          16 :     _displacement_values[i] = &_displacements[i]->adSln();
      58          16 :     _displacement_values_old[i] = &_displacements[i]->slnOld();
      59             :   }
      60           8 : }
      61             : 
      62             : ADRealVectorValue
      63       25472 : ADPenaltyVelocityContinuityNewmarkBeta::solidVelocity(const unsigned int qp) const
      64             : {
      65             :   ADRealVectorValue ret;
      66       76416 :   for (const auto i : index_range(_solid_velocities_old))
      67       50944 :     ret(i) =
      68       50944 :         InertialForceTempl<true>::computeNewmarkBetaVelAccel((*_displacement_values[i])[qp],
      69       50944 :                                                              (*_displacement_values_old[i])[qp],
      70       50944 :                                                              (*_solid_velocities_old[i])[qp],
      71       50944 :                                                              (*_solid_accelerations_old[i])[qp],
      72       50944 :                                                              _beta,
      73       50944 :                                                              _gamma,
      74       50944 :                                                              _dt)
      75       50944 :             .first;
      76       25472 :   return ret;
      77             : }