fe.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/python/common/typeregistry.hh>
#include <dune/python/functions/globalbasis.hh>
#include <dune/python/pybind11/eigen.h>
#include <dune/python/pybind11/functional.h>
#include <dune/python/pybind11/pybind11.h>
#include <dune/python/pybind11/stl.h>
 
#include <ikarus/finiteelements/fefactory.hh>
 
namespace Ikarus::Python {
 
template <class FE, class... options>
void registerCalculateAt(pybind11::handle scope, pybind11::class_<FE, options...> cls, auto restultTypesTuple) {
  using Traits         = typename FE::Traits;
  using FERequirements = typename FE::FERequirementType;
  cls.def(
      "calculateAt",
      [&](FE& self, const FERequirements& req, const Dune::FieldVector<double, Traits::mydim>& local,
          std::string resType) {
        Eigen::VectorXd result;
        bool success = false;
        Dune::Hybrid::forEach(restultTypesTuple, [&]<typename RT>(RT i) {
          if (resType == toString(i)) {
            success = true;
            result  = self.template calculateAt<RT::template Rebind>(req, local).asVec();
          }
        });
        if (success)
          return result;
        DUNE_THROW(Dune::NotImplemented, "Element " + Dune::className<FE>() + " doesn't support ResultType " + resType);
      },
      pybind11::arg("feRequirements"), pybind11::arg("local"), pybind11::arg("resultType"));
}
 
template <class FE, class... options>
void registerFE(pybind11::handle scope, pybind11::class_<FE, options...> cls) {
  using BH             = typename FE::BasisHandler;
  using GridElement    = typename FE::GridElement;
  using FERequirements = typename FE::FERequirementType;
  using FlatBasis      = typename FE::Traits::FlatBasis;
 
  int index = 0;
  cls.def(pybind11::init([](const BH& basisHandler, typename FE::PreTuple argsTuple) {
            auto unpackTuple = [&]<typename... Arg>(Arg&&... args) {
              return new FE(basisHandler, std::forward<Arg>(args)...);
            };
            return std::apply(unpackTuple, argsTuple);
          }),
          pybind11::keep_alive<1, 2>());
 
  cls.def("bind", [](FE& self, const GridElement& e) { self.bind(e); });
  cls.def("calculateScalar", [](FE& self, const FERequirements& req) { return calculateScalar(self, req); });
  cls.def("calculateVector", [](FE& self, const FERequirements& req, Eigen::Ref<Eigen::VectorXd> vec) {
    calculateVector(self, req, vec);
  });
  cls.def(
      "calculateMatrix",
      [](FE& self, const FERequirements& req, Eigen::Ref<Eigen::MatrixXd> mat) { calculateMatrix(self, req, mat); },
      pybind11::arg("FERequirements"), pybind11::arg("elementMatrix").noconvert());
 
  pybind11::module scopedf = pybind11::module::import("dune.functions");
 
  typedef Dune::Python::LocalViewWrapper<FlatBasis> LocalViewWrapper;
  auto includes = Dune::Python::IncludeFiles{"dune/python/functions/globalbasis.hh"};
  auto lv       = Dune::Python::insertClass<LocalViewWrapper>(
                scopedf, "LocalViewWrapper",
                Dune::Python::GenerateTypeName("Dune::Python::LocalViewWrapperWrapper", Dune::MetaType<FlatBasis>()),
                includes)
                .first;
  lv.def("bind", &LocalViewWrapper::bind);
  lv.def("unbind", &LocalViewWrapper::unbind);
  lv.def("index", [](const LocalViewWrapper& localView, int index) { return localView.index(index); });
  lv.def("__len__", [](LocalViewWrapper& self) -> int { return self.size(); });
 
  Dune::Python::Functions::registerTree<typename LocalViewWrapper::Tree>(lv);
  lv.def("tree", [](const LocalViewWrapper& view) { return view.tree(); });
 
  cls.def(
      "localView",
      [](FE& self) -> LocalViewWrapper {
        auto lvWrapped = LocalViewWrapper(self.localView().globalBasis());
        // this can be simplified when https://gitlab.dune-project.org/staging/dune-functions/-/merge_requests/418
        // becomes available
        // pybind11::object obj = pybind11::cast(self.localView().element());
        lvWrapped.base().bind(self.localView().element());
        return lvWrapped;
      },
      pybind11::keep_alive<0, 1>());
 
  registerCalculateAt(scope, cls, typename FE::SupportedResultTypes());
}
 
} // namespace Ikarus::Python