kinematics.h

Go to the documentation of this file.

// ---------------------------------------------------------------------
//
// Copyright (C) 2016 - 2022 by the deal.II authors
//
// This file is part of the deal.II library.
//
// The deal.II library is free software; you can use it, redistribute
// it, and/or modify it under the terms of the GNU Lesser General
// Public License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
// The full text of the license can be found in the file LICENSE.md at
// the top level directory of deal.II.
//
// ---------------------------------------------------------------------
 
#ifndef dealii_elasticity_kinematics_h
#define dealii_elasticity_kinematics_h
 
 
#include <deal.II/base/config.h>
 
#include <deal.II/base/numbers.h>
#include <deal.II/base/symmetric_tensor.h>
#include <deal.II/base/tensor.h>
 
#include <deal.II/physics/elasticity/standard_tensors.h>
 
DEAL_II_NAMESPACE_OPEN
 
namespace Physics
{
  namespace Elasticity
  {
    namespace Kinematics
    {
      template <int dim, typename Number>
      DEAL_II_ALWAYS_INLINE Tensor<2, dim, Number>
                            F(const Tensor<2, dim, Number> &Grad_u);
 
      template <int dim, typename Number>
      DEAL_II_ALWAYS_INLINE Tensor<2, dim, Number>
                            F_iso(const Tensor<2, dim, Number> &F);
 
      template <int dim, typename Number>
      DEAL_II_ALWAYS_INLINE SymmetricTensor<2, dim, Number>
                            F_vol(const Tensor<2, dim, Number> &F);
 
      template <int dim, typename Number>
      DEAL_II_ALWAYS_INLINE SymmetricTensor<2, dim, Number>
                            C(const Tensor<2, dim, Number> &F);
 
      template <int dim, typename Number>
      DEAL_II_ALWAYS_INLINE SymmetricTensor<2, dim, Number>
                            b(const Tensor<2, dim, Number> &F);
 
      template <int dim, typename Number>
      DEAL_II_ALWAYS_INLINE SymmetricTensor<2, dim, Number>
                            E(const Tensor<2, dim, Number> &F);
 
      template <int dim, typename Number>
      DEAL_II_ALWAYS_INLINE SymmetricTensor<2, dim, Number>
                            epsilon(const Tensor<2, dim, Number> &Grad_u);
 
      template <int dim, typename Number>
      DEAL_II_ALWAYS_INLINE SymmetricTensor<2, dim, Number>
                            e(const Tensor<2, dim, Number> &F);
 
      template <int dim, typename Number>
      Tensor<2, dim, Number>
      l(const Tensor<2, dim, Number> &F, const Tensor<2, dim, Number> &dF_dt);
 
      template <int dim, typename Number>
      SymmetricTensor<2, dim, Number>
      d(const Tensor<2, dim, Number> &F, const Tensor<2, dim, Number> &dF_dt);
 
      template <int dim, typename Number>
      Tensor<2, dim, Number>
      w(const Tensor<2, dim, Number> &F, const Tensor<2, dim, Number> &dF_dt);
 
    } // namespace Kinematics
  }   // namespace Elasticity
} // namespace Physics
 
 
 
#ifndef DOXYGEN
 
// ------------------------- inline functions ------------------------
 
 
 
template <int dim, typename Number>
inline Tensor<2, dim, Number>
Physics::Elasticity::Kinematics::F(const Tensor<2, dim, Number> &Grad_u)
{
  return StandardTensors<dim>::I + Grad_u;
}
 
 
 
template <int dim, typename Number>
inline Tensor<2, dim, Number>
Physics::Elasticity::Kinematics::F_iso(const Tensor<2, dim, Number> &F)
{
  // Make things work with AD types
  using std::pow;
  return internal::NumberType<Number>::value(pow(determinant(F), -1.0 / dim)) *
         F;
}
 
 
 
template <int dim, typename Number>
inline SymmetricTensor<2, dim, Number>
Physics::Elasticity::Kinematics::F_vol(const Tensor<2, dim, Number> &F)
{
  // Make things work with AD types
  using std::pow;
  return internal::NumberType<Number>::value(pow(determinant(F), 1.0 / dim)) *
         static_cast<SymmetricTensor<2, dim, Number>>(
           unit_symmetric_tensor<dim>());
}
 
 
 
template <int dim, typename Number>
inline SymmetricTensor<2, dim, Number>
Physics::Elasticity::Kinematics::C(const Tensor<2, dim, Number> &F)
{
  return symmetrize(transpose(F) * F);
}
 
 
 
template <int dim, typename Number>
inline SymmetricTensor<2, dim, Number>
Physics::Elasticity::Kinematics::b(const Tensor<2, dim, Number> &F)
{
  return symmetrize(F * transpose(F));
}
 
 
 
template <int dim, typename Number>
inline SymmetricTensor<2, dim, Number>
Physics::Elasticity::Kinematics::E(const Tensor<2, dim, Number> &F)
{
  return internal::NumberType<Number>::value(0.5) *
         (C(F) - static_cast<SymmetricTensor<2, dim, Number>>(
                   StandardTensors<dim>::I));
}
 
 
 
template <int dim, typename Number>
inline SymmetricTensor<2, dim, Number>
Physics::Elasticity::Kinematics::epsilon(const Tensor<2, dim, Number> &Grad_u)
{
  // This is the equivalent to 0.5*symmetrize(Grad_u + transpose(Grad_u));
  return symmetrize(Grad_u);
}
 
 
 
template <int dim, typename Number>
inline SymmetricTensor<2, dim, Number>
Physics::Elasticity::Kinematics::e(const Tensor<2, dim, Number> &F)
{
  const Tensor<2, dim, Number> F_inv = invert(F);
  return internal::NumberType<Number>::value(0.5) *
         symmetrize(static_cast<SymmetricTensor<2, dim, Number>>(
                      StandardTensors<dim>::I) -
                    transpose(F_inv) * F_inv);
}
 
 
 
template <int dim, typename Number>
inline Tensor<2, dim, Number>
Physics::Elasticity::Kinematics::l(const Tensor<2, dim, Number> &F,
                                   const Tensor<2, dim, Number> &dF_dt)
{
  return dF_dt * invert(F);
}
 
 
 
template <int dim, typename Number>
inline SymmetricTensor<2, dim, Number>
Physics::Elasticity::Kinematics::d(const Tensor<2, dim, Number> &F,
                                   const Tensor<2, dim, Number> &dF_dt)
{
  return symmetrize(l(F, dF_dt));
}
 
 
 
template <int dim, typename Number>
inline Tensor<2, dim, Number>
Physics::Elasticity::Kinematics::w(const Tensor<2, dim, Number> &F,
                                   const Tensor<2, dim, Number> &dF_dt)
{
  // This could be implemented as w = l-d, but that would mean computing "l"
  // a second time.
  const Tensor<2, dim> grad_v = l(F, dF_dt);
  return internal::NumberType<Number>::value(0.5) *
         (grad_v - transpose(grad_v));
}
 
#endif // DOXYGEN
 
DEAL_II_NAMESPACE_CLOSE
 
#endif