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

#include <ComputeGrainForceAndTorque.h>

Inheritance diagram for ComputeGrainForceAndTorque:

Public Member Functions
	ComputeGrainForceAndTorque (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...

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< Real > > * >	_dFdgradeta

std::vector< const MaterialProperty< Real > * >	_test_derivatives


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 ComputeGrainForceAndTorque.h.

Constructor & Destructor Documentation

◆ ComputeGrainForceAndTorque()

ComputeGrainForceAndTorque::ComputeGrainForceAndTorque ( const InputParameters & parameters )

Definition at line 30 of file ComputeGrainForceAndTorque.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),
     _dFdgradeta(_op_num)
 {
   for (unsigned int i = 0; i < _op_num; ++i)
   {
     _vals_var[i] = coupled("etas", i);
     _vals_name[i] = getVar("etas", i)->name();
     _dFdgradeta[i] = &getMaterialPropertyByName<std::vector<Real>>(
         derivativePropertyNameFirst(_dF_name, _vals_name[i]));
   }
 }

Member Function Documentation

◆ execute()

void ComputeGrainForceAndTorque::execute ( )

virtual

Definition at line 76 of file ComputeGrainForceAndTorque.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 ComputeGrainForceAndTorque::executeJacobian ( unsigned int jvar )

virtual

Definition at line 101 of file ComputeGrainForceAndTorque.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 ((*_dFdgradeta[i])[_qp][j] != 0.0)
               {
                 const Real factor = _JxW[_qp] * _coord[_qp] * (*_dFdgradeta[i])[_qp][k];
                 const RealGradient compute_torque_jacobian_eta =
                     factor * (_current_elem->centroid() - centroid).cross(_grad_phi[_j][_qp]);
                 _force_torque_eta_jacobian_store[i][(6 * j + 0) * _total_dofs + _j_global] +=
                     factor * _grad_phi[_j][_qp](0);
                 _force_torque_eta_jacobian_store[i][(6 * j + 1) * _total_dofs + _j_global] +=
                     factor * _grad_phi[_j][_qp](1);
                 _force_torque_eta_jacobian_store[i][(6 * j + 2) * _total_dofs + _j_global] +=
                     factor * _grad_phi[_j][_qp](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 ComputeGrainForceAndTorque::finalize ( )

virtual

Definition at line 162 of file ComputeGrainForceAndTorque.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 > & ComputeGrainForceAndTorque::getForceCJacobians ( ) const

virtual

Implements GrainForceAndTorqueInterface.

Definition at line 212 of file ComputeGrainForceAndTorque.C.

 {
   return _force_torque_c_jacobian_store;
 }

◆ getForceEtaJacobians()

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

virtual

Implements GrainForceAndTorqueInterface.

Definition at line 217 of file ComputeGrainForceAndTorque.C.

 {
   return _force_torque_eta_jacobian_store;
 }

◆ getForceValues()

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

virtual

Implements GrainForceAndTorqueInterface.

Definition at line 200 of file ComputeGrainForceAndTorque.C.

 {
   return _force_values;
 }

◆ getTorqueValues()

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

virtual

Implements GrainForceAndTorqueInterface.

Definition at line 206 of file ComputeGrainForceAndTorque.C.

 {
   return _torque_values;
 }

◆ initialize()

void ComputeGrainForceAndTorque::initialize ( )

virtual

Definition at line 55 of file ComputeGrainForceAndTorque.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 ComputeGrainForceAndTorque::threadJoin ( const UserObject & y )

virtual

Definition at line 184 of file ComputeGrainForceAndTorque.C.

 {
   const ComputeGrainForceAndTorque & pps = static_cast<const ComputeGrainForceAndTorque &>(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];
   }
 }