membranestrains.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 <Eigen/Core>
namespace Ikarus {
 
struct DefaultMembraneStrain
{
  template <typename GEO>
  static auto value(const Dune::FieldVector<double, 2>& gpPos, const GEO& geo,
                    const auto& uFunction) -> Eigen::Vector3<typename std::remove_cvref_t<decltype(uFunction)>::ctype> {
    using ScalarType = typename std::remove_cvref_t<decltype(uFunction)>::ctype;
    Eigen::Vector3<ScalarType> epsV;
    const auto J = Dune::toEigen(geo.jacobianTransposed(gpPos));
    using namespace Dune;
    using namespace Dune::DerivativeDirections;
    const Eigen::Matrix<ScalarType, 3, 2> gradu = toEigen(
        uFunction.evaluateDerivative(gpPos, // Here the gpIndex could be passed
                                     Dune::wrt(spatialAll), Dune::on(Dune::DerivativeDirections::referenceElement)));
    const Eigen::Matrix<ScalarType, 2, 3> j = J + gradu.transpose();
 
    epsV << J.row(0).dot(gradu.col(0)) + 0.5 * gradu.col(0).squaredNorm(),
        J.row(1).dot(gradu.col(1)) + 0.5 * gradu.col(1).squaredNorm(), j.row(0).dot(j.row(1)) - J.row(0).dot(J.row(1));
    return epsV;
  }
 
  template <typename GEO, typename ST>
  static auto derivative(const Dune::FieldVector<double, 2>& gpPos, const Eigen::Matrix<ST, 2, 3>& jcur,
                         const auto& dNAtGp, const GEO& geo, const auto& uFunction, const auto& localBasis,
                         const int node) {
    Eigen::Matrix<ST, 3, 3> bop;
    bop.row(0) = jcur.row(0) * dNAtGp(node, 0);
    bop.row(1) = jcur.row(1) * dNAtGp(node, 1);
    bop.row(2) = jcur.row(0) * dNAtGp(node, 1) + jcur.row(1) * dNAtGp(node, 0);
 
    return bop;
  }
 
  template <typename GEO, typename ST>
  static auto secondDerivative(const Dune::FieldVector<double, 2>& gpPos, const auto& dNAtGp, const GEO& geo,
                               const auto& uFunction, const auto& localBasis, const Eigen::Vector3<ST>& S, int I,
                               int J) {
    const auto& dN1i           = dNAtGp(I, 0);
    const auto& dN1j           = dNAtGp(J, 0);
    const auto& dN2i           = dNAtGp(I, 1);
    const auto& dN2j           = dNAtGp(J, 1);
    const ST NS                = dN1i * dN1j * S[0] + dN2i * dN2j * S[1] + (dN1i * dN2j + dN2i * dN1j) * S[2];
    Eigen::Matrix<ST, 3, 3> kg = Eigen::Matrix<double, 3, 3>::Identity() * NS;
    return kg;
  }
};
 
} // namespace Ikarus