linearelasticity.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 "svk.hh"
 
#include <ikarus/finiteelements/mechanics/materials/interface.hh>
 
namespace Ikarus {
 
template <typename ST>
struct LinearElasticityT : Material<LinearElasticityT<ST>>
{
  using ScalarType = ST;
  using Base       = StVenantKirchhoffT<ScalarType>;
 
  using field_type                    = ScalarType;
  static constexpr int worldDimension = 3;
  using StrainMatrix                  = Eigen::Matrix<ScalarType, worldDimension, worldDimension>;
  using StressMatrix                  = StrainMatrix;
  using MaterialParameters            = typename Base::MaterialParameters;
 
  static constexpr auto strainTag              = StrainTags::linear;
  static constexpr auto stressTag              = StressTags::linear;
  static constexpr auto tangentModuliTag       = TangentModuliTags::Material;
  static constexpr bool energyAcceptsVoigt     = Base::energyAcceptsVoigt;
  static constexpr bool stressToVoigt          = Base::stressToVoigt;
  static constexpr bool stressAcceptsVoigt     = Base::stressAcceptsVoigt;
  static constexpr bool moduliToVoigt          = Base::moduliToVoigt;
  static constexpr bool moduliAcceptsVoigt     = Base::moduliAcceptsVoigt;
  static constexpr double derivativeFactorImpl = Base::derivativeFactorImpl;
 
  [[nodiscard]] constexpr static std::string nameImpl() noexcept { return "LinearElasticity"; }
 
  explicit LinearElasticityT(const MaterialParameters& mpt)
      : svk_{mpt} {}
 
  MaterialParameters materialParametersImpl() const { return svk_.materialParametersImpl(); }
 
  template <typename Derived>
  ScalarType storedEnergyImpl(const Eigen::MatrixBase<Derived>& E) const {
    return svk_.template storedEnergyImpl(E);
  }
 
  template <bool voigt, typename Derived>
  auto stressesImpl(const Eigen::MatrixBase<Derived>& E) const {
    return svk_.template stressesImpl<voigt>(E);
  }
 
  template <bool voigt, typename Derived>
  auto tangentModuliImpl(const Eigen::MatrixBase<Derived>& E) const {
    return svk_.template tangentModuliImpl<voigt>(E);
  }
 
  template <typename STO>
  auto rebind() const {
    LinearElasticityT<STO> leRebound;
    leRebound.svk = svk_.template rebind<STO>();
    return leRebound;
  }
 
private:
  StVenantKirchhoffT<ScalarType> svk_;
};
 
using LinearElasticity = LinearElasticityT<double>;
 
} // namespace Ikarus