material.hh File Reference

Python bindings for materials. More...

#include <dune/common/classname.hh>
#include <dune/python/common/typeregistry.hh>
#include <dune/python/pybind11/eigen.h>
#include <dune/python/pybind11/pybind11.h>
#include <dune/python/pybind11/stl.h>
#include <ikarus/finiteelements/mechanics/materials.hh>
#include <ikarus/utils/concepts.hh>

Go to the source code of this file.

Namespaces
namespace	Ikarus
namespace	Ikarus::Python

Macros
#define	MAKE_MaterialFunction(clsName, materialName, functionname, vecSize)
#define	MAKE_MATERIAL_REGISTERY_FUNCTION(Materialname, vecSize)
#define	MAKE_MATERIAL_CLASS_IN_MODULE(Materialname, args)

Functions
	Ikarus::Python::MAKE_MATERIAL_REGISTERY_FUNCTION (LinearElasticity, 6)
	Ikarus::Python::MAKE_MATERIAL_REGISTERY_FUNCTION (StVenantKirchhoff, 6)
	Ikarus::Python::MAKE_MATERIAL_REGISTERY_FUNCTION (NeoHooke, 6)

Macro Definition Documentation

MAKE_MATERIAL_CLASS_IN_MODULE

#define MAKE_MATERIAL_CLASS_IN_MODULE	(		Materialname,
			args
	)

Value:

  auto includes##Materialname = Dune::Python::IncludeFiles{"ikarus/finiteelements/mechanics/materials.hh"};    \
  auto cls##Materialname                                                                                       \
      = Dune::Python::insertClass<Ikarus::Materialname<args>>(                                                 \
            m, #Materialname, Dune::Python::GenerateTypeName("Ikarus::" + std::string(#Materialname<##args>)), \
            includes##Materialname)                                                                            \
            .first;                                                                                            \
  cls##Materialname.def(pybind11::init([](double emod, double nu) {                                            \
                          auto matParameter                                                                    \
                              = Ikarus::toLamesFirstParameterAndShearModulus({.emodul = emod, .nu = nu});      \
                          return new Materialname(matParameter);                                               \
                        }),                                                                                    \
                        "Material constructor that takes Young's modulus E and Poisson's ratio nu"             \
                        "E"_a,                                                                                 \
                        "nu"_a);                                                                               \
  MAKE_MaterialFunction(Materialname<##args>, storedEnergy);                                                   \
  MAKE_MaterialFunction(Materialname<##args>, stresses);                                                       \
  MAKE_MaterialFunction(Materialname<##args>, tangentModuli);

MAKE_MATERIAL_REGISTERY_FUNCTION

#define MAKE_MATERIAL_REGISTERY_FUNCTION	(		Materialname,
			vecSize
	)

MAKE_MaterialFunction

#define MAKE_MaterialFunction	(		clsName,
			materialName,
			functionname,
			vecSize
	)

Value:

  clsName.def(                                                                                                         \
      #functionname,                                                                                                   \
      [](materialName& self, const std::string& straintag, Eigen::Ref<const Eigen::Vector<double, vecSize>> eVoigt_) { \
        if constexpr (not Concepts::IsMaterial<LinearElasticityT, materialName>) {                                     \
          Eigen::Vector<double, vecSize> eVoigt = eVoigt_;                                                             \
          if (straintag == toString(StrainTags::rightCauchyGreenTensor))                                               \
            return self.template functionname<StrainTags::rightCauchyGreenTensor>(eVoigt);                             \
          else if (straintag == toString(StrainTags::greenLagrangian))                                                 \
            return self.template functionname<StrainTags::greenLagrangian>(eVoigt);                                    \
          else if (straintag == toString(StrainTags::linear))                                                          \
            DUNE_THROW(Dune::MathError, "Passing linear strain to " + std::string(#materialName)                       \
                                            + " does not makes sense use LinearElastic class");                        \
          else if (straintag == toString(StrainTags::displacementGradient))                                            \
            DUNE_THROW(Dune::MathError,                                                                                \
                       "Passing displacementGradient strain in 6d Voigt notation does not make any sense!");           \
          else if (straintag == toString(StrainTags::deformationGradient))                                             \
            DUNE_THROW(Dune::MathError,                                                                                \
                       "Passing deformationGradient strain in 6d Voigt notation does not make any sense!");            \
          else                                                                                                         \
            DUNE_THROW(Dune::MathError, straintag + "is not a valid strain tag.");                                     \
        } else {                                                                                                       \
          Eigen::Vector<double, vecSize> eVoigt = eVoigt_; /* Linear elastic path */                                   \
          if (straintag == toString(StrainTags::linear))                                                               \
            return self.template functionname<StrainTags::linear>(eVoigt);                                             \
          else                                                                                                         \
            DUNE_THROW(Dune::MathError, "Linear elastic material only accepts linear strains!");                       \
        }                                                                                                              \
        __builtin_unreachable();                                                                                       \
      },                                                                                                               \
      "StrainName"_a, "strainVector"_a);