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

Collaboration diagram for EshelbianPlasticity::LogarithmicDirectionalDerivatives::RotationExponential:

Public Member Functions
	RotationExponential (const Vector &w)

Tensor	value () const

Tensor	first (const Vector &a) const

Tensor	second (const Vector &a, const Vector &b) const

Tensor	third (const Vector &a, const Vector &b, const Vector &c) const

template<int N>
void	fill (const Matrix< N > &argument, Matrix< N > &result) const

Public Attributes
Vector	omega

Tensor	R

FTensor::Tensor3< double, 3, 3, 3 >	dR

FTensor::Tensor4< double, 3, 3, 3, 3 >	ddR

Detailed Description

Rotation exp(skew(w)) and its directional derivatives up to third order from LieGroups::SO3 (Lie.hpp): exp, diffExp, diffDiffExp and diffDiffDiffExp contracted with the axial direction vectors. The value and the first two derivative tensors are formed once per base and reused for every direction set.

Definition at line 436 of file LogarithmicDirectionalDerivatives.hpp.

Constructor & Destructor Documentation

◆ RotationExponential()

EshelbianPlasticity::LogarithmicDirectionalDerivatives::RotationExponential::RotationExponential ( const Vector & w )

inlineexplicit

Definition at line 437 of file LogarithmicDirectionalDerivatives.hpp.

                                                : omega(w) {
    FTENSOR_INDEXES(3, i, j, k, l);
    const double theta = std::sqrt(omega(i) * omega(i));
    R(i, j) = LieGroups::SO3::exp(omega, theta)(i, j);
    dR(i, j, k) = LieGroups::SO3::diffExp(omega, theta)(i, j, k);
    ddR(i, j, k, l) = LieGroups::SO3::diffDiffExp(omega, theta)(i, j, k, l);
  }

Member Function Documentation

◆ fill()

template<int N>

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

inline

Fill the jet of exp(skew(w)): block 0 the value and the other blocks the derivatives in the axial vectors of the skew direction blocks of argument. A zero direction block gives zero derivatives.

Definition at line 474 of file LogarithmicDirectionalDerivatives.hpp.

                                                                {
    FTENSOR_INDEXES(3, i, j);
    result.data.fill(0.);
    result[0](i, j) = R(i, j);
    std::array<Vector, N> v;
    std::array<bool, N> active{};
    for (int d = 0; d != N; ++d) {
      v[d] = axial(argument[1 << d]);
      active[d] = v[d](i) * v[d](i) > 0.;
      if (active[d])
        result[1 << d](i, j) = first(v[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) = second(v[d1], v[d2])(i, j);
    if constexpr (N == 3)
      if (active[0] && active[1] && active[2])
        result[7](i, j) = third(v[0], v[1], v[2])(i, j);
  }

◆ first()

Tensor EshelbianPlasticity::LogarithmicDirectionalDerivatives::RotationExponential::first ( const Vector & a ) const

inline

Definition at line 447 of file LogarithmicDirectionalDerivatives.hpp.

                                      {
    FTENSOR_INDEXES(3, i, j, k);
    Tensor r;
    r(i, j) = dR(i, j, k) * a(k);
    return r;
  }

◆ second()

Tensor EshelbianPlasticity::LogarithmicDirectionalDerivatives::RotationExponential::second	(	const Vector &	a,
		const Vector &	b
	)		const

inline

Definition at line 454 of file LogarithmicDirectionalDerivatives.hpp.

                                                        {
    FTENSOR_INDEXES(3, i, j, k, l);
    Tensor r;
    r(i, j) = ddR(i, j, k, l) * a(k) * b(l);
    return r;
  }

◆ third()

Tensor EshelbianPlasticity::LogarithmicDirectionalDerivatives::RotationExponential::third	(	const Vector &	a,
		const Vector &	b,
		const Vector &	c
	)		const

inline

Definition at line 461 of file LogarithmicDirectionalDerivatives.hpp.

                                                                        {
    FTENSOR_INDEXES(3, i, j, k, l);
    const double theta = std::sqrt(omega(i) * omega(i));
    const auto dddR = LieGroups::SO3::diffDiffDiffExp(omega, theta, c);
    Tensor r;
    r(i, j) = dddR(i, j, k, l) * a(k) * b(l);
    return r;
  }