LogarithmicDirectionalDerivatives.hpp File Reference

Mixed directional derivatives of matrix exponentials for the reduced Hessian of the logarithmic plastic parametrisation. More...

#include <Lie.hpp>
#include <MatrixFunction.hpp>

Go to the source code of this file.

Classes
struct	EshelbianPlasticity::LogarithmicMaterialCurvature
struct	EshelbianPlasticity::LogarithmicDirectionalDerivatives::Matrix< N >
struct	EshelbianPlasticity::LogarithmicDirectionalDerivatives::SymmetricExponential
struct	EshelbianPlasticity::LogarithmicDirectionalDerivatives::RotationExponential
struct	EshelbianPlasticity::LogarithmicDirectionalDerivatives::SplitRotation
struct	EshelbianPlasticity::LogarithmicDirectionalDerivatives::DeviatorCurvature

Namespaces
namespace	EshelbianPlasticity
namespace	EshelbianPlasticity::LogarithmicDirectionalDerivatives
namespace	EshelbianPlasticity::LogarithmicDirectionalDerivatives::detail

Typedefs
using	EshelbianPlasticity::LogarithmicDirectionalDerivatives::Tensor = FTensor::Tensor2< double, 3, 3 >
using	EshelbianPlasticity::LogarithmicDirectionalDerivatives::Symmetric = FTensor::Tensor2_symmetric< double, 3 >
using	EshelbianPlasticity::LogarithmicDirectionalDerivatives::Vector = FTensor::Tensor1< double, 3 >
using	EshelbianPlasticity::LogarithmicDirectionalDerivatives::View = FTensor::Tensor2< FTensor::CursorPtr< double *, 9 >, 3, 3 >

Functions
template<int N>
void	EshelbianPlasticity::LogarithmicDirectionalDerivatives::product (const Matrix< N > &a, const Matrix< N > &b, Matrix< N > &result)
template<int N>
Matrix< N >	EshelbianPlasticity::LogarithmicDirectionalDerivatives::product (const Matrix< N > &a, const Matrix< N > &b)
template<class V >
Tensor	EshelbianPlasticity::LogarithmicDirectionalDerivatives::skew (const V &v)
Vector	EshelbianPlasticity::LogarithmicDirectionalDerivatives::axial (View block)
constexpr std::array< double, factorialTableSize >	EshelbianPlasticity::LogarithmicDirectionalDerivatives::detail::inverseFactorials ()
template<std::size_t K>
double	EshelbianPlasticity::LogarithmicDirectionalDerivatives::detail::expDividedDifferenceSeries (const std::array< double, K > &points)
DeviatorCurvature	EshelbianPlasticity::LogarithmicDirectionalDerivatives::deviatorCurvature (double c10, const Symmetric &h, const Symmetric &p, const Symmetric &s)

Variables
constexpr int	EshelbianPlasticity::LogarithmicDirectionalDerivatives::detail::factorialTableSize = 32
constexpr auto	EshelbianPlasticity::LogarithmicDirectionalDerivatives::detail::inverseFactorial = inverseFactorials()
constexpr double	EshelbianPlasticity::LogarithmicDirectionalDerivatives::detail::closeSpread = 0.1

Detailed Description

Mixed directional derivatives of matrix exponentials for the reduced Hessian of the logarithmic plastic parametrisation.

A jet, Matrix<N>, holds exp(A) together with its derivatives in up to N = 3 directions. Block mask is the mixed derivative in the directions whose bits are set, block 0 is the value; for N = 3 with directions (p, s, e), block 3 is D^2 exp(A)[p, s] and block 7 is D^3 exp(A)[p, s, e]. Jets form an algebra: product() of the jets of two factors is the jet of their product, which gives the mixed derivatives of F = R U F^p from the jets of the three exponentials without differentiating the product by hand.

The exponentials themselves are closed-form:

• SymmetricExponential, for symmetric arguments (stretches), uses the eigen-decomposition. The value is EigenMatrix::getMat (MatrixFunction.hpp), the spectral form of isotropic tensor functions used in computational plasticity [77] [75]. The derivatives are the divided-difference (Daleckii–Krein) representation of the Fr\'echet derivatives in the eigenbasis [30], [13] (Chapter V), [45] (Chapter 3), extended to second and third order as in [44]. The divided differences of exp at the eigenvalues are evaluated from the series in the complete homogeneous symmetric polynomials of the shifts from their mean when the spread is small, and recursively otherwise, which is the stable treatment of nearly coincident points [74], [31], [79].
• RotationExponential, for exp(skew(w)), uses Rodrigues' formula and its derivatives from LieGroups::SO3 (Lie.hpp) [97], with the small-angle series for the coefficient functions [43]. No series is used for the matrix exponential itself; for the background on why series and scaling-and-squaring are a poor fit for derivatives see [78] and [45] (Chapter 10).

Usage. Directions are written into the single-bit blocks of an argument jet, the base into block 0, and fill() writes the complete jet:

using namespace LogarithmicDirectionalDerivatives;
FTENSOR_INDEXES(3, i, j);
 
Matrix<3> u, f, r;                       // arguments
u[0](i, j) = t_H(i, j);                   // base: total log stretch
u[1](i, j) = t_ph(i, j);                  // direction p (adjoint)
u[2](i, j) = t_sh(i, j);                  // direction s
u[4](i, j) = t_e(i, j);                   // direction e (basis function)
f[0](i, j) = t_Hp(i, j);                  // plastic log stretch
f[2](i, j) = t_vh(i, j);                  // only a direction s
r[0](i, j) = skew(t_omega)(i, j);         // rotation vector as skew block
r[1](i, j) = skew(t_pr)(i, j);
 
const SymmetricExponential stretch(u[0]), plastic(f[0]);
const RotationExponential rotation(axial(r[0]));
Matrix<3> U, Fp, R;
stretch.fill(u, U);      // U[7] = D^3 exp(H)[ph, sh, e]
plastic.fill(f, Fp);     // blocks with bit 1 or 4 are zero
rotation.fill(r, R);     // derivatives in the axial vectors
 
const auto F = product(product(R, U), Fp); // jet of F = R U Fp
double d2 = t_P(i, j) * F[3](i, j);        // P : D^2 F[p, s]
double d3 = t_P(i, j) * F[7](i, j);        // P : D^3 F[p, s, e]
 
// exp(-Hp) from the same eigenvectors, and a stand-alone derivative
const auto inverse = plastic.negated();
const auto dexp = stretch.first(t_e);     // D exp(H)[e]
 
// Neo-Hookean deviatoric curvature, f = C10 tr exp(2 dev H):
const auto c = deviatorCurvature(c10, t_H, t_ph, t_sh);
double D2f = c.second(i, j) * t_e(i, j);  // D^2 f[s, e]
double D3f = c.third(i, j) * t_e(i, j);   // D^3 f[p, s, e]

A zero direction block gives zero derivatives, so the same argument jet can be reused with one direction changed. A base object is constructed once per quadrature point and its fill() is called for every direction set; the cost of fill() is a few hundred flops.

Definition in file LogarithmicDirectionalDerivatives.hpp.