resultevaluators.hh

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2021-2024 The Ikarus Developers mueller@ibb.uni-stuttgart.de
// SPDX-License-Identifier: LGPL-3.0-or-later
 
#pragma once
 
#include <dune/common/math.hh>
 
#include <ikarus/utils/tensorutils.hh>
 
namespace Ikarus::ResultEvaluators {
 
struct VonMises
{
  template <typename R>
  double operator()(const R& resultArray, [[maybe_unused]] const int comp) const {
    const auto s_x = resultArray(0, 0);
    const auto s_y = resultArray(1, 0);
    if constexpr (R::CompileTimeTraits::RowsAtCompileTime == 3) {
      const auto s_xy = resultArray(2, 0);
      return std::sqrt(Dune::power(s_x, 2) + Dune::power(s_y, 2) - s_x * s_y + 3 * Dune::power(s_xy, 2));
    } else {
      const auto s_z  = resultArray(2, 0);
      const auto s_yz = resultArray(3, 0);
      const auto s_xz = resultArray(4, 0);
      const auto s_xy = resultArray(5, 0);
 
      return std::sqrt(Dune::power(s_x, 2) + Dune::power(s_y, 2) + Dune::power(s_z, 2) - s_x * s_y - s_x * s_z -
                       s_y * s_z + 3 * (Dune::power(s_xy, 2) + Dune::power(s_xz, 2) + Dune::power(s_yz, 2)));
    }
  }
 
  static std::string name() { return "VonMises"; }
 
  static int ncomps() { return 1; }
};
 
template <int dim>
requires(dim == 2 or dim == 3)
struct PrincipalStress
{
  double operator()(const auto& resultArray, const int comp) const {
    auto mat = fromVoigt(resultArray, false);
    Eigen::SelfAdjointEigenSolver<decltype(mat)> eigensolver(mat, Eigen::EigenvaluesOnly);
    return eigensolver.eigenvalues()[dim - 1 - comp];
  }
 
  static std::string name() { return "PrincipalStress"; }
 
  static int ncomps() { return dim; }
};
 
} // namespace Ikarus::ResultEvaluators