vanishingstrain.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 "materialhelpers.hh"
 
#include <ikarus/finiteelements/mechanics/materials/interface.hh>
#include <ikarus/finiteelements/mechanics/materials/strainconversions.hh>
#include <ikarus/solver/nonlinearsolver/newtonraphson.hh>
#include <ikarus/utils/nonlinearoperator.hh>
 
namespace Ikarus::Materials {
 
template <auto strainIndexPair, typename MI>
struct VanishingStrain : public Material<VanishingStrain<strainIndexPair, MI>>
{
  using Underlying         = MI;                              
  using ScalarType         = typename Underlying::ScalarType; 
  using MaterialParameters = typename Underlying::MaterialParameters;
  using StrainMatrix       = typename Underlying::StrainMatrix;
  using StressMatrix       = typename Underlying::StressMatrix;
  using MaterialTensor     = typename Underlying::MaterialTensor;
  static constexpr int dim = Underlying::dim;
 
  static constexpr auto fixedPairs        = strainIndexPair; 
  static constexpr auto freeVoigtIndices  = Impl::createfreeVoigtIndices(fixedPairs);  
  static constexpr auto fixedVoigtIndices = Impl::createFixedVoigtIndices(fixedPairs); 
  static constexpr auto freeStrains       = freeVoigtIndices.size();                   
 
  static constexpr auto strainTag              = Underlying::strainTag;            
  static constexpr auto stressTag              = Underlying::stressTag;            
  static constexpr auto tangentModuliTag       = Underlying::tangentModuliTag;     
  static constexpr bool energyAcceptsVoigt     = Underlying::energyAcceptsVoigt;   
  static constexpr bool stressToVoigt          = true;                             
  static constexpr bool stressAcceptsVoigt     = true;                             
  static constexpr bool moduliToVoigt          = true;                             
  static constexpr bool moduliAcceptsVoigt     = true;                             
  static constexpr double derivativeFactorImpl = Underlying::derivativeFactorImpl; 
 
  explicit VanishingStrain(MI mat)
      : matImpl_{mat} {}
 
  [[nodiscard]] constexpr static std::string nameImpl() noexcept {
    auto matName = MI::name() + "_VanishingStrain(";
    for (auto p : fixedPairs)
      matName += "(" + std::to_string(p.row) + std::to_string(p.col) + ")";
    matName += ")";
    return matName;
  }
 
  MaterialParameters materialParametersImpl() const { return matImpl_.materialParametersImpl(); }
 
  template <typename Derived>
  ScalarType storedEnergyImpl(const Eigen::MatrixBase<Derived>& E) const {
    const auto Esol = reduceStrain(E);
    return matImpl_.storedEnergyImpl(Esol);
  }
 
  template <bool voigt, typename Derived>
  auto stressesImpl(const Eigen::MatrixBase<Derived>& E) const {
    const auto Esol  = reduceStrain(E);
    auto stressesRed = matImpl_.template stresses<Underlying::strainTag, true>(Esol);
 
    if constexpr (voigt) {
      return removeCol(stressesRed, fixedVoigtIndices);
    } else {
      stressesRed(fixedVoigtIndices).setZero();
      return fromVoigt(stressesRed, false);
    }
  }
 
  template <bool voigt, typename Derived>
  auto tangentModuliImpl(const Eigen::MatrixBase<Derived>& E) const {
    const auto Esol = reduceStrain(E);
    auto C          = matImpl_.template tangentModuli<Underlying::strainTag, true>(Esol);
    if constexpr (voigt)
      return reduceMatrix(C, fixedVoigtIndices);
    else
      return fromVoigt(C);
  }
 
  template <typename ScalarTypeOther>
  auto rebind() const {
    auto reboundMatImpl = matImpl_.template rebind<ScalarTypeOther>();
    return VanishingStrain<strainIndexPair, decltype(reboundMatImpl)>(reboundMatImpl);
  }
 
  auto& underlying() const { return matImpl_; }
 
private:
  Underlying matImpl_; 
 
  template <typename Derived>
  auto reduceStrain(const Eigen::MatrixBase<Derived>& Eraw) const {
    if constexpr (strainTag == StrainTags::linear or strainTag == StrainTags::greenLagrangian) {
      Eigen::Matrix3<ScalarType> E = Impl::maybeFromVoigt(Eraw);
      setStrainsToZero(E);
      return E;
    } else {
      decltype(auto) E               = Impl::maybeFromVoigt(Eraw);
      Eigen::Matrix3<ScalarType> Egl = transformStrain<strainTag, StrainTags::greenLagrangian>(E);
      setStrainsToZero(Egl);
      return transformStrain<StrainTags::greenLagrangian, strainTag>(Egl).derived();
    }
  }
  inline void setStrainsToZero(auto& E) const {
    for (auto [i, j] : fixedPairs) {
      E(i, j) = 0;
      E(j, i) = 0;
    }
  }
};
 
template <MatrixIndexPair... stressIndexPair, typename MaterialImpl>
auto makeVanishingStrain(MaterialImpl mat) {
  return VanishingStrain<std::to_array({stressIndexPair...}), MaterialImpl>(mat);
}
 
template <typename MaterialImpl>
auto planeStrain(const MaterialImpl& mat) {
  return makeVanishingStrain<MatrixIndexPair{2, 1}, MatrixIndexPair{2, 0}, MatrixIndexPair{2, 2}>(mat);
}
} // namespace Ikarus::Materials