EshelbianPlasticity::LogarithmicDirectionalDerivatives::SymmetricExponential Struct Reference

#include "users_modules/eshelbian_plasticity/src/LogarithmicDirectionalDerivatives.hpp"

Collaboration diagram for EshelbianPlasticity::LogarithmicDirectionalDerivatives::SymmetricExponential:

Public Member Functions
template<class A >
	SymmetricExponential (const A &a)
SymmetricExponential	negated () const
Symmetric	first (const Symmetric &e) const
Symmetric	second (const Symmetric &e1, const Symmetric &e2) const
Symmetric	third (const Symmetric &e1, const Symmetric &e2, const Symmetric &e3) const
template<int N>
void	fill (const Matrix< N > &argument, Matrix< N > &result) const

Static Public Member Functions
static Symmetric	symmetric (View block)

Public Attributes
FTensor::Tensor1< double, 3 >	values
FTensor::Tensor2< double, 3, 3 >	vectors
Symmetric	value

Private Member Functions
Tensor	toEigenbasis (const Symmetric &e) const
Symmetric	fromEigenbasis (const Tensor &t) const
Tensor	firstInBasis (const Tensor &x) const
Tensor	secondInBasis (const Tensor &x, const Tensor &y) const
Tensor	thirdInBasis (const Tensor &x, const Tensor &y, const Tensor &z) const
void	prepareDifferences ()

Static Private Member Functions
static const EigenMatrix::Fun< double > &	expFun ()

Private Attributes
double	second_ [3][3]
double	third_ [3][3][3]
double	fourth_ [3][3][3][3]

Detailed Description

Exponential of a symmetric matrix with its directional derivatives up to third order from the eigen-decomposition. The value is EigenMatrix::getMat (MatrixFunction.hpp). The derivatives use the divided-difference expansion in the eigenbasis (components X_ab of a direction, exp[...] divided differences of exp at the eigenvalues): (D exp[E])_ab = exp[l_a,l_b] E_ab, (D^2 exp[E,F])_ab = sum_c exp[l_a,l_c,l_b] (E_ac F_cb + F_ac E_cb), (D^3 exp[E,F,G])_ab = sum_{c,d} exp[l_a,l_c,l_d,l_b] sum_{perm (X,Y,Z) of (E,F,G)} X_ac Y_cd Z_db. The divided differences are evaluated as a short series when eigenvalues are close, so coincident and nearly coincident eigenvalues are exact; the confluent formulas of EigenMatrix::getDiffMat and getDiffDiffMat apply only to eigenvalues equal to 1e-14 and lose about eps/gap^2 in between. The decomposition and the difference tables are formed once per base and reused for every direction set.

Definition at line 227 of file LogarithmicDirectionalDerivatives.hpp.

Constructor & Destructor Documentation

SymmetricExponential()

template<class A >

EshelbianPlasticity::LogarithmicDirectionalDerivatives::SymmetricExponential::SymmetricExponential ( const A &  a )

inlineexplicit

Definition at line 228 of file LogarithmicDirectionalDerivatives.hpp.

                                                               {
    FTENSOR_INDEXES(3, i, j);
    vectors(i, j) = a(i, j);
    CHK_THROW_MESSAGE(MoFEM::computeEigenValuesSymmetric(vectors, values),
                      "Cannot diagonalise symmetric exponential argument");
    value = EigenMatrix::getMat(values, vectors, expFun());
    prepareDifferences();
  }

Member Function Documentation

expFun()

static const EigenMatrix::Fun< double > & EshelbianPlasticity::LogarithmicDirectionalDerivatives::SymmetricExponential::expFun ( )

inlinestaticprivate

Definition at line 307 of file LogarithmicDirectionalDerivatives.hpp.

                                                {
    static const EigenMatrix::Fun<double> f = [](double x) {
      return std::exp(x);
    };
    return f;
  }

fill()

template<int N>

void EshelbianPlasticity::LogarithmicDirectionalDerivatives::SymmetricExponential::fill ( const Matrix< N > &  argument, Matrix< N > &  result  ) const

inline

Fill the jet of exp at this base: block 0 the value, single-bit blocks the first derivatives in the (symmetric) direction blocks of argument, two-bit blocks the second and the three-bit block the third derivative. A zero direction block gives zero derivatives.

Definition at line 277 of file LogarithmicDirectionalDerivatives.hpp.

                                                                {
    FTENSOR_INDEXES(3, i, j);
    result.data.fill(0.);
    result[0](i, j) = value(i, j);
    std::array<Tensor, N> e;
    std::array<bool, N> active{};
    for (int d = 0; d != N; ++d) {
      const auto block = symmetric(argument[1 << d]);
      active[d] = block(i, j) * block(i, j) > 0.;
      if (active[d]) {
        e[d] = toEigenbasis(block);
        result[1 << d](i, j) = fromEigenbasis(firstInBasis(e[d]))(i, j);
      }
    }
    for (int d1 = 0; d1 != N; ++d1)
      for (int d2 = d1 + 1; d2 != N; ++d2)
        if (active[d1] && active[d2])
          result[(1 << d1) | (1 << d2)](i, j) =
              fromEigenbasis(secondInBasis(e[d1], e[d2]))(i, j);
    if constexpr (N == 3)
      if (active[0] && active[1] && active[2])
        result[7](i, j) = fromEigenbasis(thirdInBasis(e[0], e[1], e[2]))(i, j);
  }

first()

Symmetric EshelbianPlasticity::LogarithmicDirectionalDerivatives::SymmetricExponential::first ( const Symmetric &  e ) const

inline

D exp(A)[e]

Definition at line 248 of file LogarithmicDirectionalDerivatives.hpp.

                                            {
    return fromEigenbasis(firstInBasis(toEigenbasis(e)));
  }

firstInBasis()

Tensor EshelbianPlasticity::LogarithmicDirectionalDerivatives::SymmetricExponential::firstInBasis ( const Tensor &  x ) const

inlineprivate

Definition at line 334 of file LogarithmicDirectionalDerivatives.hpp.

                                             {
    Tensor t;
    for (int a = 0; a != 3; ++a)
      for (int b = 0; b != 3; ++b)
        t(a, b) = second_[a][b] * x(a, b);
    return t;
  }

fromEigenbasis()

Symmetric EshelbianPlasticity::LogarithmicDirectionalDerivatives::SymmetricExponential::fromEigenbasis ( const Tensor &  t ) const

inlineprivate

Definition at line 323 of file LogarithmicDirectionalDerivatives.hpp.

                                                  {
    FTENSOR_INDEXES(3, i, j);
    FTensor::Index<'a', 3> a;
    FTensor::Index<'b', 3> b;
    Tensor full;
    full(i, j) = vectors(a, i) * (t(a, b) * vectors(b, j));
    Symmetric result;
    result(i, j) = (full(i, j) || full(j, i)) / 2.;
    return result;
  }

negated()

SymmetricExponential EshelbianPlasticity::LogarithmicDirectionalDerivatives::SymmetricExponential::negated ( ) const

inline

exp(-A) from the same eigenvectors, without a second diagonalisation.

Definition at line 238 of file LogarithmicDirectionalDerivatives.hpp.

                                       {
    SymmetricExponential result(*this);
    FTENSOR_INDEXES(3, i);
    result.values(i) = -values(i);
    result.value = EigenMatrix::getMat(result.values, result.vectors, expFun());
    result.prepareDifferences();
    return result;
  }

prepareDifferences()

void EshelbianPlasticity::LogarithmicDirectionalDerivatives::SymmetricExponential::prepareDifferences ( )

inlineprivate

Divided differences of exp at the eigenvalues for every index tuple. The eigenvalues are ascending (LAPACK dsyev), so for a sorted tuple the extreme points are its first and last entry and the recursion exp[p_0..p_k] = (exp[p_1..p_k] - exp[p_0..p_{k-1}]) / (p_k - p_0) divides by the largest spread; tuples with a small spread use the series.

Definition at line 375 of file LogarithmicDirectionalDerivatives.hpp.

                            {
#ifndef NDEBUG
    if (values(0) > values(1) || values(1) > values(2))
      THROW_MESSAGE("Eigenvalues are expected in ascending order");
#endif
    const auto l = [&](int a) { return values(a); };
    const auto close = [](double spread) {
      return spread <= detail::closeSpread;
    };
    const double e[3] = {std::exp(l(0)), std::exp(l(1)), std::exp(l(2))};
    for (int a = 0; a != 3; ++a)
      for (int b = a; b != 3; ++b)
        second_[a][b] = second_[b][a] =
            close(l(b) - l(a)) ? detail::expDividedDifferenceSeries(
                                     std::array<double, 2>{l(a), l(b)})
                               : (e[b] - e[a]) / (l(b) - l(a));
    for (int a = 0; a != 3; ++a)
      for (int b = a; b != 3; ++b)
        for (int c = b; c != 3; ++c)
          third_[a][b][c] =
              close(l(c) - l(a))
                  ? detail::expDividedDifferenceSeries(
                        std::array<double, 3>{l(a), l(b), l(c)})
                  : (second_[b][c] - second_[a][b]) / (l(c) - l(a));
    for (int a = 0; a != 3; ++a)
      for (int b = 0; b != 3; ++b)
        for (int c = 0; c != 3; ++c) {
          std::array<int, 3> s{a, b, c};
          std::sort(s.begin(), s.end());
          third_[a][b][c] = third_[s[0]][s[1]][s[2]];
        }
    for (int a = 0; a != 3; ++a)
      for (int b = a; b != 3; ++b)
        for (int c = b; c != 3; ++c)
          for (int d = c; d != 3; ++d)
            fourth_[a][b][c][d] =
                close(l(d) - l(a))
                    ? detail::expDividedDifferenceSeries(
                          std::array<double, 4>{l(a), l(b), l(c), l(d)})
                    : (third_[b][c][d] - third_[a][b][c]) / (l(d) - l(a));
    for (int a = 0; a != 3; ++a)
      for (int b = 0; b != 3; ++b)
        for (int c = 0; c != 3; ++c)
          for (int d = 0; d != 3; ++d) {
            std::array<int, 4> s{a, b, c, d};
            std::sort(s.begin(), s.end());
            fourth_[a][b][c][d] = fourth_[s[0]][s[1]][s[2]][s[3]];
          }
  }

second()

Symmetric EshelbianPlasticity::LogarithmicDirectionalDerivatives::SymmetricExponential::second ( const Symmetric &  e1, const Symmetric &  e2  ) const

inline

D^2 exp(A)[e1, e2]

Definition at line 253 of file LogarithmicDirectionalDerivatives.hpp.

                                                                   {
    return fromEigenbasis(secondInBasis(toEigenbasis(e1), toEigenbasis(e2)));
  }

secondInBasis()

Tensor EshelbianPlasticity::LogarithmicDirectionalDerivatives::SymmetricExponential::secondInBasis ( const Tensor &  x, const Tensor &  y  ) const

inlineprivate

Definition at line 342 of file LogarithmicDirectionalDerivatives.hpp.

                                                               {
    Tensor t;
    for (int a = 0; a != 3; ++a)
      for (int b = 0; b != 3; ++b) {
        double sum = 0.;
        for (int c = 0; c != 3; ++c)
          sum += third_[a][c][b] * (x(a, c) * y(c, b) + y(a, c) * x(c, b));
        t(a, b) = sum;
      }
    return t;
  }

symmetric()

static Symmetric EshelbianPlasticity::LogarithmicDirectionalDerivatives::SymmetricExponential::symmetric ( View  block )

inlinestatic

Symmetric part of a jet block.

Definition at line 265 of file LogarithmicDirectionalDerivatives.hpp.

                                         {
    FTENSOR_INDEXES(3, i, j);
    Symmetric result;
    result(i, j) = (block(i, j) || block(j, i)) / 2.;
    return result;
  }

third()

Symmetric EshelbianPlasticity::LogarithmicDirectionalDerivatives::SymmetricExponential::third ( const Symmetric &  e1, const Symmetric &  e2, const Symmetric &  e3  ) const

inline

D^3 exp(A)[e1, e2, e3]

Definition at line 258 of file LogarithmicDirectionalDerivatives.hpp.

                                             {
    return fromEigenbasis(
        thirdInBasis(toEigenbasis(e1), toEigenbasis(e2), toEigenbasis(e3)));
  }

thirdInBasis()

Tensor EshelbianPlasticity::LogarithmicDirectionalDerivatives::SymmetricExponential::thirdInBasis ( const Tensor &  x, const Tensor &  y, const Tensor &  z  ) const

inlineprivate

Definition at line 354 of file LogarithmicDirectionalDerivatives.hpp.

                                                                               {
    Tensor t;
    for (int a = 0; a != 3; ++a)
      for (int b = 0; b != 3; ++b) {
        double sum = 0.;
        for (int c = 0; c != 3; ++c)
          for (int d = 0; d != 3; ++d)
            sum += fourth_[a][c][d][b] *
                   (x(a, c) * y(c, d) * z(d, b) + x(a, c) * z(c, d) * y(d, b) +
                    y(a, c) * x(c, d) * z(d, b) + y(a, c) * z(c, d) * x(d, b) +
                    z(a, c) * x(c, d) * y(d, b) + z(a, c) * y(c, d) * x(d, b));
        t(a, b) = sum;
      }
    return t;
  }

toEigenbasis()

Tensor EshelbianPlasticity::LogarithmicDirectionalDerivatives::SymmetricExponential::toEigenbasis ( const Symmetric &  e ) const

inlineprivate

Definition at line 314 of file LogarithmicDirectionalDerivatives.hpp.

                                                {
    FTENSOR_INDEXES(3, i, j);
    FTensor::Index<'a', 3> a;
    FTensor::Index<'b', 3> b;
    Tensor c;
    c(a, b) = vectors(a, i) * (e(i, j) * vectors(b, j));
    return c;
  }

Member Data Documentation

fourth_

double EshelbianPlasticity::LogarithmicDirectionalDerivatives::SymmetricExponential::fourth_[3][3][3][3]

private

Definition at line 428 of file LogarithmicDirectionalDerivatives.hpp.

second_

double EshelbianPlasticity::LogarithmicDirectionalDerivatives::SymmetricExponential::second_[3][3]

private

exp[l_a,l_b], exp[l_a,l_b,l_c], exp[l_a,l_b,l_c,l_d].

Definition at line 426 of file LogarithmicDirectionalDerivatives.hpp.

third_

double EshelbianPlasticity::LogarithmicDirectionalDerivatives::SymmetricExponential::third_[3][3][3]

private

Definition at line 427 of file LogarithmicDirectionalDerivatives.hpp.

value

Symmetric EshelbianPlasticity::LogarithmicDirectionalDerivatives::SymmetricExponential::value

Definition at line 304 of file LogarithmicDirectionalDerivatives.hpp.

values

FTensor::Tensor1<double, 3> EshelbianPlasticity::LogarithmicDirectionalDerivatives::SymmetricExponential::values

Definition at line 301 of file LogarithmicDirectionalDerivatives.hpp.

vectors

FTensor::Tensor2<double, 3, 3> EshelbianPlasticity::LogarithmicDirectionalDerivatives::SymmetricExponential::vectors

Eigenvectors in rows (MoFEM convention).

Definition at line 303 of file LogarithmicDirectionalDerivatives.hpp.

---

The documentation for this struct was generated from the following file:

• users_modules/eshelbian_plasticity/src/LogarithmicDirectionalDerivatives.hpp