greenlagrangestrain.hh

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2021-2025 The Ikarus Developers mueller@ibb.uni-stuttgart.de
// SPDX-License-Identifier: LGPL-3.0-or-later
 
#pragma once
 
#include <dune/common/fvector.hh>
#include <dune/localfefunctions/eigenDuneTransformations.hh>
#include <dune/localfefunctions/expressions/greenLagrangeStrains.hh>
 
#include <Eigen/Core>
 
namespace Ikarus::EAS {
struct GreenLagrangeStrain
{
  template <typename GEO, typename EAST>
  static auto value(const GEO& geo, const auto& uFunction, const Dune::FieldVector<double, GEO::mydimension>& gpPos,
                    const EAST& easFunction, const auto& alpha) {
    using namespace Dune::DerivativeDirections;
    using namespace Dune;
    constexpr int myDim        = GEO::mydimension;
    const auto& strainFunction = Dune::greenLagrangeStrains(uFunction);
    const auto E               = (strainFunction.evaluate(gpPos, on(gridElement))).eval();
    const auto Etilde          = (easFunction(gpPos) * alpha).eval();
    return (E + Etilde).eval();
  }
 
  template <int wrtCoeff, typename GEO, typename EAST>
  static auto firstDerivative(const GEO& geo, const auto& uFunction, const auto& localBasis, const auto& gpIndex,
                              const Dune::FieldVector<double, GEO::mydimension>& gpPos, const EAST& easFunction,
                              const auto& alpha, const int node = sNaN) {
    if constexpr (wrtCoeff == 0) {
      using namespace Dune::DerivativeDirections;
      using namespace Dune;
      constexpr int myDim        = GEO::mydimension;
      const auto& strainFunction = Dune::greenLagrangeStrains(uFunction);
      const auto bopI            = strainFunction.evaluateDerivative(gpIndex, wrt(coeff(node)), on(gridElement));
      return bopI.eval();
    } else if constexpr (wrtCoeff == 1) {
      return easFunction(gpPos);
    } else
      static_assert(Dune::AlwaysFalse<GEO>::value,
                    "firstDerivative can only be called with wrtCoeff as 0 and 1 indicating first derivative of the "
                    "Green-Lagrange strain w.r.t d and "
                    "alpha, respectively.");
  }
 
  template <int wrtCoeff, typename GEO, typename ST, typename EAST>
  static auto secondDerivative(const GEO& geo, const auto& uFunction, const auto& localBasis, const auto& gpIndex,
                               const Dune::FieldVector<double, GEO::mydimension>& gpPos,
                               const Eigen::Vector<ST, GEO::mydimension*(GEO::mydimension + 1) / 2>& S,
                               const EAST& easFunction, const auto& alpha, const int I = sNaN, const int J = sNaN) {
    constexpr int myDim              = GEO::mydimension;
    constexpr int enhancedStrainSize = EAST::enhancedStrainSize;
    if constexpr (wrtCoeff == 0) {
      using namespace Dune::DerivativeDirections;
      using namespace Dune;
      const auto& strainFunction = Dune::greenLagrangeStrains(uFunction);
      const auto kg = strainFunction.evaluateDerivative(gpIndex, wrt(coeff(I, J)), along(S), on(gridElement));
      return kg.eval(); // E_dd
    } else if constexpr (wrtCoeff == 1) {
      const auto kg = Eigen::Matrix<ST, enhancedStrainSize, enhancedStrainSize>::Zero().eval();
      return kg; // E_aa
    } else if constexpr (wrtCoeff == 2) {
      const auto kg = Eigen::Matrix<ST, enhancedStrainSize, myDim>::Zero().eval();
      return kg; // E_ad
    } else
      static_assert(
          Dune::AlwaysFalse<GEO>::value,
          "secondDerivative can only be called with wrtCoeff as 0, 1 and 2 indicating second derivative of the "
          "Green-Lagrange strain w.r.t d and "
          "alpha and the mixed derivative, respectively.");
  }
 
  static constexpr auto name() { return std::string("Green-Lagrange Strain"); }
 
private:
  static constexpr int sNaN = std::numeric_limits<int>::signaling_NaN();
};
 
} // namespace Ikarus::EAS