This class is here to get the force and torque acting on a grain. More...

#include <ComputeExternalGrainForceAndTorque.h>

Inheritance diagram for ComputeExternalGrainForceAndTorque:

Public Member Functions
	ComputeExternalGrainForceAndTorque (const InputParameters &parameters)

virtual void	initialize ()

virtual void	execute ()

virtual void	executeJacobian (unsigned int jvar)

virtual void	finalize ()

virtual void	threadJoin (const UserObject &y)

virtual const std::vector< RealGradient > &	getForceValues () const

virtual const std::vector< RealGradient > &	getTorqueValues () const

virtual const std::vector< Real > &	getForceCJacobians () const

virtual const std::vector< std::vector< Real > > &	getForceEtaJacobians () const

Protected Attributes
unsigned int	_qp

VariableName	_c_name

unsigned int	_c_var

MaterialPropertyName	_dF_name
	material property that provides force density More...

const MaterialProperty< std::vector< RealGradient > > &	_dF

const MaterialProperty< std::vector< RealGradient > > &	_dFdc
	material property that provides jacobian of force density with respect to c More...

const unsigned int	_op_num
	no. of order parameters More...

const GrainTrackerInterface &	_grain_tracker
	provide UserObject for calculating grain volumes and centers More...

unsigned int	_grain_num

unsigned int	_ncomp

std::vector< unsigned int >	_vals_var

std::vector< VariableName >	_vals_name

std::vector< const MaterialProperty< std::vector< RealGradient > > * >	_dFdeta


std::vector< RealGradient >	_force_values
	providing grain forces, torques and their jacobians w. r. t c More...

std::vector< RealGradient >	_torque_values

std::vector< Real >	_force_torque_store
	vector storing grain force and torque values More...

std::vector< Real >	_force_torque_c_jacobian_store
	vector storing jacobian of grain force and torque values More...

std::vector< std::vector< Real > >	_force_torque_eta_jacobian_store

unsigned int	_total_dofs

Detailed Description

This class is here to get the force and torque acting on a grain.

Definition at line 26 of file ComputeExternalGrainForceAndTorque.h.

Constructor & Destructor Documentation

◆ ComputeExternalGrainForceAndTorque()

ComputeExternalGrainForceAndTorque::ComputeExternalGrainForceAndTorque ( const InputParameters & parameters )

Definition at line 30 of file ComputeExternalGrainForceAndTorque.C.

   : DerivativeMaterialInterface<ShapeElementUserObject>(parameters),
     GrainForceAndTorqueInterface(),
     _c_name(getVar("c", 0)->name()),
     _c_var(coupled("c")),
     _dF_name(getParam<MaterialPropertyName>("force_density")),
     _dF(getMaterialPropertyByName<std::vector<RealGradient>>(_dF_name)),
     _dFdc(getMaterialPropertyByName<std::vector<RealGradient>>(
         derivativePropertyNameFirst(_dF_name, _c_name))),
     _op_num(coupledComponents("etas")),
     _grain_tracker(getUserObject<GrainTrackerInterface>("grain_data")),
     _vals_var(_op_num),
     _vals_name(_op_num),
     _dFdeta(_op_num)
 {
   for (unsigned int i = 0; i < _op_num; ++i)
   {
     _vals_var[i] = coupled("etas", i);
     _vals_name[i] = getVar("etas", i)->name();
     _dFdeta[i] = &getMaterialPropertyByName<std::vector<RealGradient>>(
         derivativePropertyNameFirst(_dF_name, _vals_name[i]));
   }
 }

Member Function Documentation

◆ execute()

void ComputeExternalGrainForceAndTorque::execute ( )

virtual

Definition at line 77 of file ComputeExternalGrainForceAndTorque.C.

 {
   const auto & op_to_grains = _grain_tracker.getVarToFeatureVector(_current_elem->id());
  
   for (unsigned int i = 0; i < _grain_num; ++i)
     for (unsigned int j = 0; j < _op_num; ++j)
       if (i == op_to_grains[j])
       {
         const auto centroid = _grain_tracker.getGrainCentroid(i);
         for (_qp = 0; _qp < _qrule->n_points(); ++_qp)
           if (_dF[_qp][j](0) != 0.0 || _dF[_qp][j](1) != 0.0 || _dF[_qp][j](2) != 0.0)
           {
             const RealGradient compute_torque =
                 _JxW[_qp] * _coord[_qp] * (_current_elem->centroid() - centroid).cross(_dF[_qp][j]);
             _force_torque_store[6 * i + 0] += _JxW[_qp] * _coord[_qp] * _dF[_qp][j](0);
             _force_torque_store[6 * i + 1] += _JxW[_qp] * _coord[_qp] * _dF[_qp][j](1);
             _force_torque_store[6 * i + 2] += _JxW[_qp] * _coord[_qp] * _dF[_qp][j](2);
             _force_torque_store[6 * i + 3] += compute_torque(0);
             _force_torque_store[6 * i + 4] += compute_torque(1);
             _force_torque_store[6 * i + 5] += compute_torque(2);
           }
       }
 }

◆ executeJacobian()

void ComputeExternalGrainForceAndTorque::executeJacobian ( unsigned int jvar )

virtual

Definition at line 102 of file ComputeExternalGrainForceAndTorque.C.

 {
   const auto & op_to_grains = _grain_tracker.getVarToFeatureVector(_current_elem->id());
  
   if (jvar == _c_var)
     for (unsigned int i = 0; i < _grain_num; ++i)
       for (unsigned int j = 0; j < _op_num; ++j)
         if (i == op_to_grains[j])
         {
           const auto centroid = _grain_tracker.getGrainCentroid(i);
           for (_qp = 0; _qp < _qrule->n_points(); ++_qp)
             if (_dFdc[_qp][j](0) != 0.0 || _dFdc[_qp][j](1) != 0.0 || _dFdc[_qp][j](2) != 0.0)
             {
               const Real factor = _JxW[_qp] * _coord[_qp] * _phi[_j][_qp];
               const RealGradient compute_torque_jacobian_c =
                   factor * (_current_elem->centroid() - centroid).cross(_dFdc[_qp][j]);
               _force_torque_c_jacobian_store[(6 * i + 0) * _total_dofs + _j_global] +=
                   factor * _dFdc[_qp][j](0);
               _force_torque_c_jacobian_store[(6 * i + 1) * _total_dofs + _j_global] +=
                   factor * _dFdc[_qp][j](1);
               _force_torque_c_jacobian_store[(6 * i + 2) * _total_dofs + _j_global] +=
                   factor * _dFdc[_qp][j](2);
               _force_torque_c_jacobian_store[(6 * i + 3) * _total_dofs + _j_global] +=
                   compute_torque_jacobian_c(0);
               _force_torque_c_jacobian_store[(6 * i + 4) * _total_dofs + _j_global] +=
                   compute_torque_jacobian_c(1);
               _force_torque_c_jacobian_store[(6 * i + 5) * _total_dofs + _j_global] +=
                   compute_torque_jacobian_c(2);
             }
         }
  
   for (unsigned int i = 0; i < _op_num; ++i)
     if (jvar == _vals_var[i])
       for (unsigned int j = 0; j < _grain_num; ++j)
         for (unsigned int k = 0; k < _op_num; ++k)
           if (j == op_to_grains[k])
           {
             const auto centroid = _grain_tracker.getGrainCentroid(j);
             for (_qp = 0; _qp < _qrule->n_points(); ++_qp)
               if ((*_dFdeta[i])[_qp][j](0) != 0.0 || (*_dFdeta[i])[_qp][j](1) != 0.0 ||
                   (*_dFdeta[i])[_qp][j](2) != 0.0)
               {
                 const Real factor = _JxW[_qp] * _coord[_qp] * _phi[_j][_qp];
                 const RealGradient compute_torque_jacobian_eta =
                     factor * (_current_elem->centroid() - centroid).cross((*_dFdeta[i])[_qp][k]);
                 _force_torque_eta_jacobian_store[i][(6 * j + 0) * _total_dofs + _j_global] +=
                     factor * (*_dFdeta[i])[_qp][k](0);
                 _force_torque_eta_jacobian_store[i][(6 * j + 1) * _total_dofs + _j_global] +=
                     factor * (*_dFdeta[i])[_qp][k](1);
                 _force_torque_eta_jacobian_store[i][(6 * j + 2) * _total_dofs + _j_global] +=
                     factor * (*_dFdeta[i])[_qp][k](2);
                 _force_torque_eta_jacobian_store[i][(6 * j + 3) * _total_dofs + _j_global] +=
                     compute_torque_jacobian_eta(0);
                 _force_torque_eta_jacobian_store[i][(6 * j + 4) * _total_dofs + _j_global] +=
                     compute_torque_jacobian_eta(1);
                 _force_torque_eta_jacobian_store[i][(6 * j + 5) * _total_dofs + _j_global] +=
                     compute_torque_jacobian_eta(2);
               }
           }
 }

◆ finalize()

void ComputeExternalGrainForceAndTorque::finalize ( )

virtual

Definition at line 164 of file ComputeExternalGrainForceAndTorque.C.

 {
   gatherSum(_force_torque_store);
   for (unsigned int i = 0; i < _grain_num; ++i)
   {
     _force_values[i](0) = _force_torque_store[6 * i + 0];
     _force_values[i](1) = _force_torque_store[6 * i + 1];
     _force_values[i](2) = _force_torque_store[6 * i + 2];
     _torque_values[i](0) = _force_torque_store[6 * i + 3];
     _torque_values[i](1) = _force_torque_store[6 * i + 4];
     _torque_values[i](2) = _force_torque_store[6 * i + 5];
   }
  
   if (_fe_problem.currentlyComputingJacobian())
   {
     gatherSum(_force_torque_c_jacobian_store);
     for (unsigned int i = 0; i < _op_num; ++i)
       gatherSum(_force_torque_eta_jacobian_store[i]);
   }
 }

◆ getForceCJacobians()

const std::vector< Real > & ComputeExternalGrainForceAndTorque::getForceCJacobians ( ) const

virtual

Implements GrainForceAndTorqueInterface.

Definition at line 215 of file ComputeExternalGrainForceAndTorque.C.

 {
   return _force_torque_c_jacobian_store;
 }

◆ getForceEtaJacobians()

const std::vector< std::vector< Real > > & ComputeExternalGrainForceAndTorque::getForceEtaJacobians ( ) const

virtual

Implements GrainForceAndTorqueInterface.

Definition at line 220 of file ComputeExternalGrainForceAndTorque.C.

 {
   return _force_torque_eta_jacobian_store;
 }

◆ getForceValues()

const std::vector< RealGradient > & ComputeExternalGrainForceAndTorque::getForceValues ( ) const

virtual

Implements GrainForceAndTorqueInterface.

Definition at line 203 of file ComputeExternalGrainForceAndTorque.C.

 {
   return _force_values;
 }

◆ getTorqueValues()

const std::vector< RealGradient > & ComputeExternalGrainForceAndTorque::getTorqueValues ( ) const

virtual

Implements GrainForceAndTorqueInterface.

Definition at line 209 of file ComputeExternalGrainForceAndTorque.C.

 {
   return _torque_values;
 }

◆ initialize()

void ComputeExternalGrainForceAndTorque::initialize ( )

virtual

Definition at line 56 of file ComputeExternalGrainForceAndTorque.C.

 {
   _grain_num = _grain_tracker.getTotalFeatureCount();
   _ncomp = 6 * _grain_num;
  
   _force_values.resize(_grain_num);
   _torque_values.resize(_grain_num);
   _force_torque_store.assign(_ncomp, 0.0);
  
   if (_fe_problem.currentlyComputingJacobian())
   {
     _total_dofs = _subproblem.es().n_dofs();
     _force_torque_c_jacobian_store.assign(_ncomp * _total_dofs, 0.0);
     _force_torque_eta_jacobian_store.resize(_op_num);
  
     for (unsigned int i = 0; i < _op_num; ++i)
       _force_torque_eta_jacobian_store[i].assign(_ncomp * _total_dofs, 0.0);
   }
 }

◆ threadJoin()

void ComputeExternalGrainForceAndTorque::threadJoin ( const UserObject & y )

virtual

Definition at line 186 of file ComputeExternalGrainForceAndTorque.C.

 {
   const ComputeExternalGrainForceAndTorque & pps =
       static_cast<const ComputeExternalGrainForceAndTorque &>(y);
   for (unsigned int i = 0; i < _ncomp; ++i)
     _force_torque_store[i] += pps._force_torque_store[i];
   if (_fe_problem.currentlyComputingJacobian())
   {
     for (unsigned int i = 0; i < _ncomp * _total_dofs; ++i)
       _force_torque_c_jacobian_store[i] += pps._force_torque_c_jacobian_store[i];
     for (unsigned int i = 0; i < _op_num; ++i)
       for (unsigned int j = 0; j < _ncomp * _total_dofs; ++j)
         _force_torque_eta_jacobian_store[i][j] += pps._force_torque_eta_jacobian_store[i][j];
   }
 }