The finite strain mechanics approach used in the MOOSE tensor_mechanics module is the incremental corotational form from [Rashid 1993](http://onlinelibrary.wiley.com/doi/10.1002/nme.1620362302/abstract). In this form, the generic time increment under consideration is such that $$t \in [t_n, t_{n+1}]$$. The configurations of the material element under consideration at $$t = t_n$$ and $$t = t_{n+1}$$ are denoted by $$\kappa_n$$, and $$\kappa_{n + 1}$$, respectively. The incremental motion over the time increment is assumed to be given in the form of the inverse of the deformation gradient $$\hat{\mathbf{F}}$$ of $$\kappa_{n + 1}$$ with respect to $$\kappa_n$$, which may be written as

$$
\hat{\mathbf{F}}^{-1} = 1 - \frac{\partial \hat{\mathbf{u}}}{\partial \mathbf{x}},
$$

where $$\hat{\mathbf{u}}(\mathbf{x})$$ is the incremental displacement field for the time step, and $$\mathbf{x}$$ is the position vector of materials points in $$\kappa_{n+1}$$. Note that $$\hat{\mathbf{F}}$$ is NOT the deformation gradient, but rather the incremental deformation gradient of $$\kappa_{n+1}$$ with respect to $$\kappa_n$$. Thus, $$\hat{\mathbf{F}} = \mathbf{F}_{n+1} \mathbf{F}_n^{-1}$$, where $$\mathbf{F}_n$$ is the total deformation gradient at time $$t_n$$.

For this form, we assume
$$
\begin{eqnarray}
\dot{\mathbf{F}} \mathbf{F}^{-1} &=& \mathbf{D}\ \mathrm{(constant\ and\ symmetric),\ } t_n<t<t_{n+1}\\
\mathbf{F}(t^{-}_{n+1}) &=& \hat{\mathbf{U}}\ \mathrm{(symmetric\ positive\ definite)}\\
\mathbf{F}(t_{n+1}) &=& \hat{\mathbf{R}} \hat{\mathbf{U}} = \hat{\mathbf{F}}\ (\hat{\mathbf{R}}\ \mathrm{proper\ orthogonal})
\end{eqnarray}
$$

The stress rate is calculated in the `Compute*Stress` classes, where either elasticity or plasticity options can be used.

The base material class for the finite strain calculations is [ComputeFiniteStrain](http://mooseframework.com/docs/doxygen/modules/classComputeFiniteStrain.html). In that material, $$\hat{\mathbf{F}}$$ is calculated in the computeStrain function, including a volumetric locking correction of
$$
\hat{\mathbf{F}}_{corr} = \hat{\mathbf{F}} \left( \frac{|\mathrm{av}_{el}(\hat{\mathbf{F}})|}{|\hat{\mathbf{F}}|} \right)^{\frac{1}{3}},
$$
where $$\mathrm{av}_{el}()$$ is the average value for the entire element. The strain increment and the rotation increment are calculated in `computeQpStrain()`. Once the strain increment is calculated, it is added to the total strain from $$t_n$$. The total strain from $$t_{n+1}$$ must then be rotated using the rotation increment. An portion of the code, which performs this rotation, is shown below.

```C++
  void ComputeFiniteStrain::computeQpStrain()
{
  .
  .
  .
  //Update strain in intermediate configuration
  _mechanical_strain[_qp] = _mechanical_strain_old[_qp] + _strain_increment[_qp];
  _total_strain[_qp] = _total_strain_old[_qp] + total_strain_increment;

  //Rotate strain to current configuration
  _mechanical_strain[_qp] = _rotation_increment[_qp] * _mechanical_strain[_qp] * _rotation_increment[_qp].transpose();
  _total_strain[_qp] = _rotation_increment[_qp] * _total_strain[_qp] * _rotation_increment[_qp].transpose();

}
```

### Input File Use

The finite strain material is designed to be used with any incremental stress material, such as complex plasticity and creep models or a linear elastic model, such as [ComputeFiniteStrainElasticStress](http://mooseframework.org/docs/doxygen/modules/classComputeFiniteStrainElasticStress.html). An example portion of an input file using these three materials is shown below:
```yaml
  # Tensor Mechanics
  [Materials]
    [./elasticity_tensor]
      type = ComputeIsotropicElasticityTensor
      block = 0
      youngs_modulus = 2.1e5
      poissons_ratio = 0.3
    [../]
    [./strain]
      type = ComputeFiniteStrain
      block = 0
      displacements = 'disp_x disp_y disp_z'
    [../]
    [./stress]
      type = ComputeFiniteStrainElasticStress
      block = 0
    [../]
  []
```

Finite strain formulations for 1D spherically symmetric and 2D axisymmetric problems are also included in MOOSE; more information on these specialized materials can be found [here](http://mooseframework.com/wiki/PhysicsModules/TensorMechanics/LowerOrderGeometryMaterials/).

#### Input file conversion from Solid Mechanics to Tensor Mechanics
The material combination `ComputeFiniteStrain`, `ComputeFiniteStrainElasticStress`, and an elasticity tensor material will replace the Solid Mechanics `SolidModel` model with the `formulation = Nonlinear3D`.  An equivalent solid mechanics input file to the Tensor Mechanics input file shown above is:

```yaml
  # Old Solid Mechanics Version
  [Materials]
    [./linelast]
      type = Elastic
      block = 0
      disp_x = disp_x
      disp_y = disp_y
      disp_z = disp_z
      poissons_ratio = 0.3
      youngs_modulus = 2.1e5
      formulation = Nonlinear3D
    [../]
  []
```