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 "SingleGrainRigidBodyMotion.h"
      11             : #include "GrainTrackerInterface.h"
      12             : 
      13             : registerMooseObject("PhaseFieldApp", SingleGrainRigidBodyMotion);
      14             : 
      15             : InputParameters
      16         215 : SingleGrainRigidBodyMotion::validParams()
      17             : {
      18         215 :   InputParameters params = GrainRigidBodyMotionBase::validParams();
      19         215 :   params.addClassDescription("Adds rigid mody motion to a single grain");
      20         430 :   params.addParam<unsigned int>("op_index", 0, "Grain number for the kernel to be applied");
      21         215 :   return params;
      22           0 : }
      23             : 
      24         115 : SingleGrainRigidBodyMotion::SingleGrainRigidBodyMotion(const InputParameters & parameters)
      25         230 :   : GrainRigidBodyMotionBase(parameters), _op_index(getParam<unsigned int>("op_index"))
      26             : {
      27         115 : }
      28             : 
      29             : Real
      30     4143504 : SingleGrainRigidBodyMotion::computeQpResidual()
      31             : {
      32     4143504 :   return _velocity_advection * _grad_u[_qp] * _test[_i][_qp];
      33             : }
      34             : 
      35             : Real
      36    20140480 : SingleGrainRigidBodyMotion::computeQpJacobian()
      37             : {
      38    20140480 :   return _velocity_advection * _grad_phi[_j][_qp] * _test[_i][_qp] +
      39    20140480 :          _velocity_advection_jacobian * _grad_u[_qp] * _test[_i][_qp];
      40             : }
      41             : 
      42             : Real
      43    42892160 : SingleGrainRigidBodyMotion::computeQpOffDiagJacobian(unsigned int /*jvar*/)
      44             : {
      45    42892160 :   return _velocity_advection_jacobian * _grad_u[_qp] * _test[_i][_qp];
      46             : }
      47             : 
      48     1327104 : Real SingleGrainRigidBodyMotion::computeQpNonlocalJacobian(dof_id_type /*dof_index*/)
      49             : {
      50     1327104 :   return _velocity_advection_jacobian * _grad_u[_qp] * _test[_i][_qp];
      51             : }
      52             : 
      53             : Real
      54     2654208 : SingleGrainRigidBodyMotion::computeQpNonlocalOffDiagJacobian(unsigned int /*jvar*/,
      55             :                                                              dof_id_type /*dof_index*/)
      56             : {
      57     2654208 :   return _velocity_advection_jacobian * _grad_u[_qp] * _test[_i][_qp];
      58             : }
      59             : 
      60             : void
      61    29748660 : SingleGrainRigidBodyMotion::getUserObjectJacobian(unsigned int jvar, dof_id_type dof_index)
      62             : {
      63             :   _velocity_advection_jacobian = 0.0;
      64             : 
      65    29748660 :   auto grain_id = _grain_ids[_op_index];
      66    29748660 :   if (grain_id != FeatureFloodCount::invalid_id)
      67             :   {
      68             :     mooseAssert(grain_id < _grain_volumes.size(), "grain_id out of bounds");
      69     8794188 :     const auto volume = _grain_volumes[grain_id];
      70     8794188 :     const auto centroid = _grain_tracker.getGrainCentroid(grain_id);
      71             :     RealGradient force_jacobian;
      72             :     RealGradient torque_jacobian;
      73             : 
      74     8794188 :     if (jvar == _c_var)
      75             :     {
      76     2915412 :       force_jacobian(0) = _grain_force_c_jacobians[(6 * grain_id + 0) * _total_dofs + dof_index];
      77     2915412 :       force_jacobian(1) = _grain_force_c_jacobians[(6 * grain_id + 1) * _total_dofs + dof_index];
      78     2915412 :       force_jacobian(2) = _grain_force_c_jacobians[(6 * grain_id + 2) * _total_dofs + dof_index];
      79     2915412 :       torque_jacobian(0) = _grain_force_c_jacobians[(6 * grain_id + 3) * _total_dofs + dof_index];
      80     2915412 :       torque_jacobian(1) = _grain_force_c_jacobians[(6 * grain_id + 4) * _total_dofs + dof_index];
      81     2915412 :       torque_jacobian(2) = _grain_force_c_jacobians[(6 * grain_id + 5) * _total_dofs + dof_index];
      82             :     }
      83             : 
      84    25944012 :     for (unsigned int jvar_index = 0; jvar_index < _op_num; ++jvar_index)
      85    17149824 :       if (jvar == _vals_var[jvar_index])
      86             :       {
      87     5684640 :         force_jacobian(0) =
      88     5684640 :             _grain_force_eta_jacobians[jvar_index][(6 * grain_id + 0) * _total_dofs + dof_index];
      89     5684640 :         force_jacobian(1) =
      90     5684640 :             _grain_force_eta_jacobians[jvar_index][(6 * grain_id + 1) * _total_dofs + dof_index];
      91     5684640 :         force_jacobian(2) =
      92     5684640 :             _grain_force_eta_jacobians[jvar_index][(6 * grain_id + 2) * _total_dofs + dof_index];
      93     5684640 :         torque_jacobian(0) =
      94     5684640 :             _grain_force_eta_jacobians[jvar_index][(6 * grain_id + 3) * _total_dofs + dof_index];
      95     5684640 :         torque_jacobian(1) =
      96     5684640 :             _grain_force_eta_jacobians[jvar_index][(6 * grain_id + 4) * _total_dofs + dof_index];
      97     5684640 :         torque_jacobian(2) =
      98     5684640 :             _grain_force_eta_jacobians[jvar_index][(6 * grain_id + 5) * _total_dofs + dof_index];
      99             :       }
     100             : 
     101     8794188 :     const auto force_jac = _mt / volume * force_jacobian;
     102             :     const auto torque_jac =
     103     8794188 :         _mr / volume * torque_jacobian.cross(_current_elem->vertex_average() - centroid);
     104             : 
     105     8794188 :     _velocity_advection_jacobian = (force_jac + torque_jac);
     106             :   }
     107    29748660 : }
     108             : 
     109             : void
     110      685056 : SingleGrainRigidBodyMotion::calculateAdvectionVelocity()
     111             : {
     112             :   _velocity_advection = 0.0;
     113      685056 :   _grain_ids = _grain_tracker.getVarToFeatureVector(_current_elem->id());
     114             : 
     115      685056 :   auto grain_id = _grain_ids[_op_index];
     116      685056 :   if (grain_id != FeatureFloodCount::invalid_id)
     117             :   {
     118             :     mooseAssert(grain_id < _grain_volumes.size(), "grain_id out of bounds");
     119      220553 :     const auto volume = _grain_volumes[grain_id];
     120      220553 :     const auto centroid = _grain_tracker.getGrainCentroid(grain_id);
     121      220553 :     const auto force = _mt / volume * _grain_forces[grain_id];
     122             :     const auto torque =
     123      220553 :         _mr / volume * (_grain_torques[grain_id].cross(_current_elem->vertex_average() - centroid));
     124             : 
     125      220553 :     _velocity_advection = (force + torque);
     126             :   }
     127      685056 : }