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          21 : ADPenaltyVelocityContinuityNewmarkBeta::validParams()
      17             : {
      18          21 :   InputParameters params = ADPenaltyVelocityContinuity::validParams();
      19          21 :   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          42 :   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          42 :   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          42 :   params.addRequiredParam<Real>("beta", "beta parameter for Newmark-Beta time integration");
      31          42 :   params.addRequiredParam<Real>("gamma", "gamma parameter for Newmark-Beta time integration");
      32          21 :   return params;
      33           0 : }
      34             : 
      35          12 : ADPenaltyVelocityContinuityNewmarkBeta::ADPenaltyVelocityContinuityNewmarkBeta(
      36          12 :     const InputParameters & parameters)
      37             :   : ADPenaltyVelocityContinuity(parameters),
      38          24 :     _beta(getParam<Real>("beta")),
      39          36 :     _gamma(getParam<Real>("gamma"))
      40             : {
      41          24 :   _solid_velocities_old.resize(coupledComponents("solid_velocities"));
      42          36 :   for (const auto i : index_range(_solid_velocities_old))
      43          24 :     _solid_velocities_old[i] = &coupledValueOld("solid_velocities", i);
      44             : 
      45          24 :   _solid_accelerations_old.resize(coupledComponents("solid_accelerations"));
      46          36 :   for (const auto i : index_range(_solid_accelerations_old))
      47          24 :     _solid_accelerations_old[i] = &coupledValueOld("solid_accelerations", i);
      48             : 
      49          12 :   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          12 :   _displacement_values.resize(_displacements.size());
      54          12 :   _displacement_values_old.resize(_displacements.size());
      55          36 :   for (const auto i : index_range(_displacement_values))
      56             :   {
      57          24 :     _displacement_values[i] = &_displacements[i]->adSln();
      58          24 :     _displacement_values_old[i] = &_displacements[i]->slnOld();
      59             :   }
      60          12 : }
      61             : 
      62             : ADRealVectorValue
      63       30528 : ADPenaltyVelocityContinuityNewmarkBeta::solidVelocity(const unsigned int qp) const
      64             : {
      65             :   ADRealVectorValue ret;
      66       91584 :   for (const auto i : index_range(_solid_velocities_old))
      67       61056 :     ret(i) =
      68       61056 :         InertialForceTempl<true>::computeNewmarkBetaVelAccel((*_displacement_values[i])[qp],
      69       61056 :                                                              (*_displacement_values_old[i])[qp],
      70       61056 :                                                              (*_solid_velocities_old[i])[qp],
      71       61056 :                                                              (*_solid_accelerations_old[i])[qp],
      72       61056 :                                                              _beta,
      73       61056 :                                                              _gamma,
      74       61056 :                                                              _dt)
      75       61056 :             .first;
      76       30528 :   return ret;
      77             : }