EshelbianPlasticity::GriffithCohesiveLaw Struct Reference

Collaboration diagram for EshelbianPlasticity::GriffithCohesiveLaw:

Static Public Member Functions
template<typename T >
static T	getTau (const T &k, double gc)
template<typename T >
static auto	getDiffTau (const T &tau, const T &kappa, double gc)
template<typename T >
static T	getAlpha (const T &kappa, double gc, double min_stiffness)
template<typename T >
static T	getDiffAlpha (const T &kappa, double gc, double min_stiffness)
template<typename T >
static auto	invTau (const T &tau, double Gf)
template<typename T >
static auto	calculateY (const T t_eff, const T &kappa, double gc, double min_stiffness)
template<typename T >
static auto	calculateDissipation (const T &delta_kappa, const T t_eff, const T &kappa, double gc, double min_stiffness)
template<typename T >
static auto	calculateDissipationSurplus (const T &delta_kappa, const T t_eff, const T &kappa, double gc, double min_stiffness)
template<typename T >
static auto	calculateDissipationSurplusDiffKappa (const T &delta_kappa, const T &t_eff, const T &kappa, double gc, double min_stiffness)
template<typename T >
static auto	calculateDissipationSurplusDiffTraction (const FTensor::Tensor1< T, 3 > &t_traction, const T &delta_kappa, const T &kappa, FTensor::Tensor1< double, 3 > &t_n_normalize, double gc, double beta, double min_stiffness)
template<typename T >
static auto	calculateGap (const FTensor::Tensor1< T, 3 > &t_traction, FTensor::Tensor1< double, 3 > &t_n_normalize, double alpha, double beta, bool sign_sensitive=true)
template<typename T >
static auto	calculateDiffGapDTraction (const FTensor::Tensor1< T, 3 > &t_traction, FTensor::Tensor1< double, 3 > &t_n_normalize, double alpha, double beta, bool sign_sensitive=true)
template<typename T >
static auto	calculateEffectiveTraction (const FTensor::Tensor1< T, 3 > &t_traction, FTensor::Tensor1< double, 3 > &t_n_normalize, double beta)

Static Public Attributes
static constexpr double	eps = 1e-8
static constexpr double	pi = boost::math::constants::pi<double>()
static constexpr double	root_pi

Detailed Description

Definition at line 26 of file EshelbianCohesive.cpp.

Member Function Documentation

calculateDiffGapDTraction()

template<typename T >

static auto EshelbianPlasticity::GriffithCohesiveLaw::calculateDiffGapDTraction ( const FTensor::Tensor1< T, 3 > &  t_traction, FTensor::Tensor1< double, 3 > &  t_n_normalize, double  alpha, double  beta, bool  sign_sensitive = true  )

inlinestatic

Definition at line 174 of file EshelbianCohesive.cpp.

                                                        {
    FTENSOR_INDEX(3, i);
    FTensor::Tensor2<T, 3, 3> t_dgap;
    FTensor::Tensor1<std::complex<T>, 3> t_cpx_delta;
    FTensor::Tensor1<std::complex<T>, 3> t_cpx_traction;
    for (auto jj = 0; jj != 3; ++jj) {
      t_cpx_traction(i) = t_traction(i);
      t_cpx_traction(jj) += eps * 1i;
      auto [teff_cpx, t_cpx_gap] = calculateGap(t_cpx_traction, t_n_normalize,
                                                alpha, beta, sign_sensitive);
      for (auto ii = 0; ii != 3; ++ii) {
        auto v = t_cpx_gap(ii).imag();
        t_dgap(ii, jj) = v / eps;
      }
    }
    return t_dgap;
  }

calculateDissipation()

template<typename T >

static auto EshelbianPlasticity::GriffithCohesiveLaw::calculateDissipation ( const T &  delta_kappa, const T  t_eff, const T &  kappa, double  gc, double  min_stiffness  )

inlinestatic

Definition at line 71 of file EshelbianCohesive.cpp.

                                                         {
    T Y = calculateY(t_eff, kappa + delta_kappa, gc, min_stiffness);
    return Y * delta_kappa;
  }

calculateDissipationSurplus()

template<typename T >

static auto EshelbianPlasticity::GriffithCohesiveLaw::calculateDissipationSurplus ( const T &  delta_kappa, const T  t_eff, const T &  kappa, double  gc, double  min_stiffness  )

inlinestatic

Definition at line 79 of file EshelbianCohesive.cpp.

                                                                {
    T M = calculateY(t_eff, kappa + delta_kappa, gc, min_stiffness) -
          getTau(kappa + delta_kappa, gc);
    return -M * delta_kappa;
  }

calculateDissipationSurplusDiffKappa()

template<typename T >

static auto EshelbianPlasticity::GriffithCohesiveLaw::calculateDissipationSurplusDiffKappa ( const T &  delta_kappa, const T &  t_eff, const T &  kappa, double  gc, double  min_stiffness  )

inlinestatic

Definition at line 88 of file EshelbianCohesive.cpp.

                                                                         {
 
    std::complex<T> cpx_delta = delta_kappa;
    std::complex<T> cpx_t_eff = t_eff;
    std::complex<T> cpx_kappa = kappa;
    cpx_delta += eps * 1i;
    std::complex<T> cpx_M =
        calculateDissipationSurplus(cpx_delta, cpx_t_eff, cpx_kappa, gc, min_stiffness);
    return cpx_M.imag() / eps;
  }

calculateDissipationSurplusDiffTraction()

template<typename T >

static auto EshelbianPlasticity::GriffithCohesiveLaw::calculateDissipationSurplusDiffTraction ( const FTensor::Tensor1< T, 3 > &  t_traction, const T &  delta_kappa, const T &  kappa, FTensor::Tensor1< double, 3 > &  t_n_normalize, double  gc, double  beta, double  min_stiffness  )

inlinestatic

Definition at line 103 of file EshelbianCohesive.cpp.

                                         {
    FTENSOR_INDEX(3, i);
    FTensor::Tensor1<double, 3> t_diff_traction;
    std::complex<T> cpx_delta = delta_kappa;
    std::complex<T> cpx_kappa = kappa;
    FTensor::Tensor1<std::complex<T>, 3> t_cpx_traction;
    for (auto jj = 0; jj != 3; ++jj) {
      t_cpx_traction(i) = t_traction(i);
      t_cpx_traction(jj) += eps * 1i;
      std::complex<T> cpx_teff =
          calculateEffectiveTraction(t_cpx_traction, t_n_normalize, beta);
      std::complex<T> cpx_M = calculateDissipationSurplus(
          cpx_delta, cpx_teff, cpx_kappa, gc, min_stiffness);
      t_diff_traction(jj) = cpx_M.imag() / eps;
    }
    return t_diff_traction;
  }

calculateEffectiveTraction()

template<typename T >

static auto EshelbianPlasticity::GriffithCohesiveLaw::calculateEffectiveTraction ( const FTensor::Tensor1< T, 3 > &  t_traction, FTensor::Tensor1< double, 3 > &  t_n_normalize, double  beta  )

inlinestatic

Definition at line 197 of file EshelbianCohesive.cpp.

                                          {
    auto [teff, t_gap] = calculateGap(t_traction, t_n_normalize, 1.0, beta);
    return teff;
  }

calculateGap()

template<typename T >

static auto EshelbianPlasticity::GriffithCohesiveLaw::calculateGap ( const FTensor::Tensor1< T, 3 > &  t_traction, FTensor::Tensor1< double, 3 > &  t_n_normalize, double  alpha, double  beta, bool  sign_sensitive = true  )

inlinestatic

Definition at line 125 of file EshelbianCohesive.cpp.

                                                       {
    FTENSOR_INDEX(3, i);
    FTENSOR_INDEX(3, j);
    constexpr auto t_kd = FTensor::Kronecker_Delta<double>();
    FTensor::Tensor2<T, 3, 3> t_P;
    t_P(i, j) = t_n_normalize(i) * t_n_normalize(j);
    FTensor::Tensor2<T, 3, 3> t_Q;
    t_Q(i, j) = t_kd(i, j) - t_P(i, j);
    FTensor::Tensor1<T, 3> t_normal;
    t_normal(i) = t_P(i, j) * t_traction(j);
    FTensor::Tensor1<T, 3> t_tangential;
    t_tangential(i) = t_Q(i, j) * t_traction(j);
 
    if (sign_sensitive) {
      T s = std::sqrt((t_normal(i) * t_normal(i)) / 4. +
                      (1. / beta) * t_tangential(i) * t_tangential(i));
      T teff = (t_n_normalize(i) * t_normal(i) / 2.) + s;
 
      FTensor::Tensor1<T, 3> t_gap{0., 0., 0.};
      if (std::real(s) > std::numeric_limits<double>::epsilon()) {
        t_gap(i) = alpha * (
 
                               t_n_normalize(i) * teff / 2. +
 
                               (1.0 / 4.0) * (teff / s) * t_normal(i) +
 
                               (1.0 / beta) * (teff / s) * t_tangential(i)
 
                           );
      }
      return std::make_pair(teff, t_gap);
    } else {
      T teff = std::sqrt((t_normal(i) * t_normal(i)) +
                         (1. / beta) * t_tangential(i) * t_tangential(i));
      FTensor::Tensor1<T, 3> t_gap;
      t_gap(i) = alpha * (
 
                             t_normal(i) + (1.0 / beta) * t_tangential(i)
 
                         );
      return std::make_pair(teff, t_gap);
    }
  }

calculateY()

template<typename T >

static auto EshelbianPlasticity::GriffithCohesiveLaw::calculateY ( const T  t_eff, const T &  kappa, double  gc, double  min_stiffness  )

inlinestatic

Definition at line 64 of file EshelbianCohesive.cpp.

                                               {
    T diff_alpha = getDiffAlpha(kappa, gc, min_stiffness);
    return 0.5 * t_eff * t_eff * diff_alpha;
  }

getAlpha()

template<typename T >

static T EshelbianPlasticity::GriffithCohesiveLaw::getAlpha ( const T &  kappa, double  gc, double  min_stiffness  )

inlinestatic

Definition at line 45 of file EshelbianCohesive.cpp.

                                                                     {
    auto tau = getTau(kappa, gc);
    return kappa / (kappa * min_stiffness + tau);
  }

getDiffAlpha()

template<typename T >

static T EshelbianPlasticity::GriffithCohesiveLaw::getDiffAlpha ( const T &  kappa, double  gc, double  min_stiffness  )

inlinestatic

Definition at line 51 of file EshelbianCohesive.cpp.

                                                                         {
    T tau = getTau(kappa, gc);
    T diff_tau = getDiffTau(tau, kappa, gc);
    T dnom = kappa * min_stiffness + tau;
    return (tau - kappa * diff_tau) / (dnom * dnom);
  }

getDiffTau()

template<typename T >

static auto EshelbianPlasticity::GriffithCohesiveLaw::getDiffTau ( const T &  tau, const T &  kappa, double  gc  )

inlinestatic

Definition at line 40 of file EshelbianCohesive.cpp.

                                                                         {
    return -tau * (1.0 + (1.0 / (2.0 * kappa)));
  }

getTau()

template<typename T >

static T EshelbianPlasticity::GriffithCohesiveLaw::getTau ( const T &  k, double  gc  )

inlinestatic

Definition at line 34 of file EshelbianCohesive.cpp.

                                                                      {
    const T c = static_cast<T>(gc) / root_pi;
    return c * std::exp(-k) / std::sqrt(k);
  }

invTau()

template<typename T >

static auto EshelbianPlasticity::GriffithCohesiveLaw::invTau ( const T &  tau, double  Gf  )

inlinestatic

Definition at line 58 of file EshelbianCohesive.cpp.

                                                                    {
    const T z = (2.0 * Gf * Gf) / (pi * tau * tau);
    return T(0.5) * boost::math::lambert_w(z, 0); // k=0 == principal branch
  }

Member Data Documentation

eps

constexpr double EshelbianPlasticity::GriffithCohesiveLaw::eps = 1e-8

inlinestaticconstexpr

Definition at line 28 of file EshelbianCohesive.cpp.

pi

constexpr double EshelbianPlasticity::GriffithCohesiveLaw::pi = boost::math::constants::pi<double>()

inlinestaticconstexpr

Definition at line 30 of file EshelbianCohesive.cpp.

root_pi

constexpr double EshelbianPlasticity::GriffithCohesiveLaw::root_pi

inlinestaticconstexpr

Initial value:

=
      boost::math::constants::root_pi<double>()

Definition at line 31 of file EshelbianCohesive.cpp.

---

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

• users_modules/eshelbian_plasticity/src/impl/EshelbianCohesive.cpp