Skip to content
Snippets Groups Projects
Commit c687a166 authored by Dr. Felix Tobias Schindler's avatar Dr. Felix Tobias Schindler
Browse files

[P|functions.expression] drop header, refactor bindings

parent e386f863
No related branches found
No related tags found
1 merge request!20Update bindings
Hide whitespace changes
Inline Side-by-side
python/dune/xt/functions/expression.cc
+ 254
− 21
View file @ c687a166
...@@ -19,10 +19,244 @@ ...@@ -19,10 +19,244 @@
#include <dune/pybindxi/pybind11.h> #include <dune/pybindxi/pybind11.h>
#include <dune/pybindxi/stl.h> #include <dune/pybindxi/stl.h>
#include <dune/xt/common/string.hh>
#include <dune/xt/grid/gridprovider/provider.hh>
#include <dune/xt/grid/type_traits.hh>
#include <dune/xt/functions/expression.hh>
#include <python/dune/xt/common/fvector.hh>
#include <python/dune/xt/common/fmatrix.hh>
#include <python/dune/xt/common/bindings.hh> #include <python/dune/xt/common/bindings.hh>
#include <python/dune/xt/grid/traits.hh>
#include <python/dune/xt/common/exceptions.bindings.hh> #include <python/dune/xt/common/exceptions.bindings.hh>
#include "expression.hh" namespace Dune {
namespace XT {
namespace Functions {
namespace bindings {
template <size_t d, size_t r = 1, size_t rC = 1, class R = double>
class ExpressionFunction
{
using type = Functions::ExpressionFunction<d, r, rC, R>;
using base_type = Functions::FunctionInterface<d, r, rC, R>;
using bound_type = pybind11::class_<type, base_type>;
template <size_t r_ = r, size_t rC_ = rC, bool anything = true> // the matrix-valued case
struct addbind
{
static void ctor(bound_type& c)
{
namespace py = pybind11;
using namespace pybind11::literals;
c.def(py::init<const std::string&,
const Common::FieldMatrix<std::string, r, rC>&,
const Common::FieldVector<Common::FieldMatrix<std::string, rC, d>, r>&,
const size_t,
const std::string>(),
"variable"_a,
"expressions"_a,
"gradient_expressions"_a,
"order"_a,
"name"_a = type::static_id());
c.def(py::init<const std::string&,
const Common::FieldMatrix<std::string, r, rC>&,
const size_t,
const std::string>(),
"variable"_a,
"expressions"_a,
"order"_a,
"name"_a = type::static_id());
} // ... ctor(...)
static void factory(pybind11::module& m, const std::string& ClassId)
{
namespace py = pybind11;
using namespace pybind11::literals;
m.def(ClassId.c_str(),
[](Grid::bindings::Dimension<d> /*dim_domain*/,
const std::string& variable,
const Common::FieldMatrix<std::string, r, rC>& expressions,
const Common::FieldVector<Common::FieldMatrix<std::string, rC, d>, r>& gradient_expressions,
const size_t order,
const std::string& name) { return type(variable, expressions, gradient_expressions, order, name); },
"dim_domain"_a,
"variable"_a,
"expressions"_a,
"gradient_expressions"_a,
"order"_a,
"name"_a = type::static_id());
m.def(ClassId.c_str(),
[](Grid::bindings::Dimension<d> /*dim_domain*/,
const std::string& variable,
const Common::FieldMatrix<std::string, r, rC>& expressions,
const size_t order,
const std::string& name) { return type(variable, expressions, order, name); },
"dim_domain"_a,
"variable"_a,
"expressions"_a,
"order"_a,
"name"_a = type::static_id());
} // ... factory(...)
}; // struct addbind, the matrix-valued case
template <size_t r_, bool anything> // the vector-valued case
struct addbind<r_, 1, anything>
{
static void ctor(bound_type& c)
{
namespace py = pybind11;
using namespace pybind11::literals;
c.def(py::init<const std::string&,
const Common::FieldVector<std::string, r>&,
const Common::FieldMatrix<std::string, r, d>&,
const size_t,
const std::string>(),
"variable"_a,
"expressions"_a,
"gradient_expressions"_a,
"order"_a,
"name"_a = type::static_id());
c.def(py::init<const std::string&, const Common::FieldVector<std::string, r>&, const size_t, const std::string>(),
"variable"_a,
"expressions"_a,
"order"_a,
"name"_a = type::static_id());
} // ... ctor(...)
static void factory(pybind11::module& m, const std::string& ClassId)
{
namespace py = pybind11;
using namespace pybind11::literals;
m.def(ClassId.c_str(),
[](Grid::bindings::Dimension<d> /*dim_domain*/,
const std::string& variable,
const Common::FieldVector<std::string, r>& expressions,
const Common::FieldMatrix<std::string, r, d>& gradient_expressions,
const size_t order,
const std::string& name) { return type(variable, expressions, gradient_expressions, order, name); },
"dim_domain"_a,
"variable"_a,
"expressions"_a,
"gradient_expressions"_a,
"order"_a,
"name"_a = type::static_id());
m.def(ClassId.c_str(),
[](Grid::bindings::Dimension<d> /*dim_domain*/,
const std::string& variable,
const Common::FieldVector<std::string, r>& expressions,
const size_t order,
const std::string& name) { return type(variable, expressions, order, name); },
"dim_domain"_a,
"variable"_a,
"expressions"_a,
"order"_a,
"name"_a = type::static_id());
} // ... factory(...)
}; // struct addbind, the vector-valued case
template <bool anything>
struct addbind<1, 1, anything> // the scalar case
{
static void ctor(bound_type& c)
{
namespace py = pybind11;
using namespace pybind11::literals;
c.def(py::init([](const std::string& variable,
const std::string& expression,
const Common::FieldVector<std::string, d>& gradient_expressions,
const size_t order,
const std::string& name) {
Common::FieldMatrix<std::string, 1, d> gradient_expressions_mat;
gradient_expressions_mat[0] = gradient_expressions;
return new type(
variable, Common::FieldVector<std::string, 1>(expression), gradient_expressions_mat, order, name);
}),
"variable"_a,
"expression"_a,
"gradient_expressions"_a,
"order"_a,
"name"_a = type::static_id());
c.def(py::init([](const std::string& variable,
const std::string& expression,
const size_t order,
const std::string& name) {
return new type(variable, Common::FieldVector<std::string, 1>(expression), order, name);
}),
"variable"_a,
"expression"_a,
"order"_a,
"name"_a = type::static_id());
} // ... ctor(...)
static void factory(pybind11::module& m, const std::string& ClassId)
{
namespace py = pybind11;
using namespace pybind11::literals;
m.def(ClassId.c_str(),
[](Grid::bindings::Dimension<d> /*dim_domain*/,
const std::string& variable,
const std::string& expression,
const Common::FieldVector<std::string, d>& gradient_expressions,
const size_t order,
const std::string& name) {
Common::FieldMatrix<std::string, 1, d> gradient_expressions_mat;
gradient_expressions_mat[0] = gradient_expressions;
return new type(
variable, Common::FieldVector<std::string, 1>(expression), gradient_expressions_mat, order, name);
},
"dim_domain"_a,
"variable"_a,
"expression"_a,
"gradient_expressions"_a,
"order"_a,
"name"_a = type::static_id());
m.def(ClassId.c_str(),
[](Grid::bindings::Dimension<d> /*dim_domain*/,
const std::string& variable,
const std::string& expression,
const size_t order,
const std::string& name) { return new type(variable, expression, order, name); },
"dim_domain"_a,
"variable"_a,
"expression"_a,
"order"_a,
"name"_a = type::static_id());
} // ... factory(...)
}; // struct addbind, the scalar case
public:
static bound_type bind(pybind11::module& m, const std::string& class_id = "expression_function")
{
namespace py = pybind11;
using namespace pybind11::literals;
std::string class_name = class_id + "_" + Common::to_string(d) + "_to_" + Common::to_string(r);
if (rC > 1)
class_name += "x" + Common::to_string(rC);
class_name += "d";
const auto ClassName = Common::to_camel_case(class_name);
bound_type c(m, ClassName.c_str(), XT::Common::to_camel_case(class_id).c_str());
addbind<>::ctor(c);
addbind<>::factory(m, Common::to_camel_case(class_id));
return c;
}
}; // class ExpressionFunction
} // namespace bindings
} // namespace Functions
} // namespace XT
} // namespace Dune
PYBIND11_MODULE(_functions_expression, m) PYBIND11_MODULE(_functions_expression, m)
...@@ -30,28 +264,27 @@ PYBIND11_MODULE(_functions_expression, m) ...@@ -30,28 +264,27 @@ PYBIND11_MODULE(_functions_expression, m)
namespace py = pybind11; namespace py = pybind11;
py::module::import("dune.xt.common"); py::module::import("dune.xt.common");
py::module::import("dune.xt.grid");
py::module::import("dune.xt.la"); py::module::import("dune.xt.la");
py::module::import("dune.xt.functions._functions_function_interface_1d"); py::module::import("dune.xt.functions._functions_function_interface_1d");
py::module::import("dune.xt.functions._functions_function_interface_2d"); py::module::import("dune.xt.functions._functions_function_interface_2d");
py::module::import("dune.xt.functions._functions_function_interface_3d"); py::module::import("dune.xt.functions._functions_function_interface_3d");
using namespace Dune::XT::Functions; Dune::XT::Functions::bindings::ExpressionFunction<1, 1, 1>::bind(m);
Dune::XT::Functions::bindings::ExpressionFunction<1, 2, 1>::bind(m);
bind_ExpressionFunction<1, 1, 1>(m); Dune::XT::Functions::bindings::ExpressionFunction<1, 2, 2>::bind(m);
bind_ExpressionFunction<1, 2, 1>(m); Dune::XT::Functions::bindings::ExpressionFunction<1, 3, 1>::bind(m);
bind_ExpressionFunction<1, 2, 2>(m); Dune::XT::Functions::bindings::ExpressionFunction<1, 3, 3>::bind(m);
bind_ExpressionFunction<1, 3, 1>(m);
bind_ExpressionFunction<1, 3, 3>(m); Dune::XT::Functions::bindings::ExpressionFunction<2, 1, 1>::bind(m);
Dune::XT::Functions::bindings::ExpressionFunction<2, 2, 1>::bind(m);
bind_ExpressionFunction<2, 1, 1>(m); Dune::XT::Functions::bindings::ExpressionFunction<2, 2, 2>::bind(m);
bind_ExpressionFunction<2, 2, 1>(m); Dune::XT::Functions::bindings::ExpressionFunction<2, 3, 1>::bind(m);
bind_ExpressionFunction<2, 2, 2>(m); Dune::XT::Functions::bindings::ExpressionFunction<2, 3, 3>::bind(m);
bind_ExpressionFunction<2, 3, 1>(m);
bind_ExpressionFunction<2, 3, 3>(m); Dune::XT::Functions::bindings::ExpressionFunction<3, 1, 1>::bind(m);
Dune::XT::Functions::bindings::ExpressionFunction<3, 2, 1>::bind(m);
bind_ExpressionFunction<3, 1, 1>(m); Dune::XT::Functions::bindings::ExpressionFunction<3, 2, 2>::bind(m);
bind_ExpressionFunction<3, 2, 1>(m); Dune::XT::Functions::bindings::ExpressionFunction<3, 3, 1>::bind(m);
bind_ExpressionFunction<3, 2, 2>(m); Dune::XT::Functions::bindings::ExpressionFunction<3, 3, 3>::bind(m);
bind_ExpressionFunction<3, 3, 1>(m); } // PYBIND11_MODULE(...)
bind_ExpressionFunction<3, 3, 3>(m);
}
python/dune/xt/functions/expression.hh deleted 100644 → 0
+ 0
− 280
View file @ e386f863
// This file is part of the dune-xt project:
// https://github.com/dune-community/dune-xt
// Copyright 2009-2020 dune-xt developers and contributors. All rights reserved.
// License: Dual licensed as BSD 2-Clause License (http://opensource.org/licenses/BSD-2-Clause)
// or GPL-2.0+ (http://opensource.org/licenses/gpl-license)
// with "runtime exception" (http://www.dune-project.org/license.html)
// Authors:
// Felix Schindler (2016 - 2017, 2019)
// René Fritze (2018 - 2019)
// Tim Keil (2018)
// Tobias Leibner (2018 - 2020)
#ifndef PYTHON_DUNE_XT_FUNCTIONS_EXPRESSION_HH
#define PYTHON_DUNE_XT_FUNCTIONS_EXPRESSION_HH
#include <dune/pybindxi/pybind11.h>
#include <dune/pybindxi/stl.h>
#include <dune/xt/common/string.hh>
#include <dune/xt/grid/type_traits.hh>
#include <dune/xt/grid/gridprovider/provider.hh>
#include <dune/xt/functions/expression.hh>
#include <python/dune/xt/common/fvector.hh>
#include <python/dune/xt/common/fmatrix.hh>
namespace Dune {
namespace XT {
namespace Functions {
namespace internal {
template <size_t d, size_t r, size_t rC>
struct addbind_ExpressionFunction_scalar_ctor
{
template <class C>
void operator()(C& /*c*/, const std::string& /*static_id*/)
{}
};
template <size_t d, size_t r>
struct addbind_ExpressionFunction_scalar_ctor<d, r, 1>
{
template <class C>
void operator()(C& c, const std::string& static_id)
{
namespace py = pybind11;
using namespace pybind11::literals;
c.def(py::init<const std::string,
const Common::FieldVector<std::string, r>,
const Common::FieldMatrix<std::string, r, d>,
const size_t,
const std::string>(),
"variable"_a,
"expressions"_a,
"gradient_expressions"_a,
"order"_a,
"name"_a = static_id);
c.def(py::init<const std::string, const Common::FieldVector<std::string, r>, const size_t, const std::string>(),
"variable"_a,
"expressions"_a,
"order"_a,
"name"_a = static_id);
}
}; // struct addbind_ExpressionFunction_scalar_ctor<1, 1>
} // namespace internal
/**
* \note We would like to drop the d template paremter and use either of
\code
static const size_t d = G::dimension;
static const constexpr size_t d = G::dimension;
\endcode
* but this triggers a bug in gcc-4.9 and we thus need to use G::dimension
* everywhere: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=59937
*/
template <size_t d, size_t r>
pybind11::class_<ExpressionFunction<d, r, 3, double>, FunctionInterface<d, r, 3, double>>
bind_ExpressionFunction(pybind11::module& m, std::integral_constant<int, 3>)
{
namespace py = pybind11;
using namespace pybind11::literals;
const size_t rC = 3;
using R = double;
using I = FunctionInterface<d, r, rC, R>;
using C = ExpressionFunction<d, r, rC, R>;
const std::string c_name =
"ExpressionFunction__" + Common::to_string(d) + "d_to_" + Common::to_string(r) + "x" + Common::to_string(rC);
py::class_<C, I> c(m, std::string(c_name).c_str(), std::string(c_name).c_str());
internal::addbind_ExpressionFunction_scalar_ctor<d, r, rC>()(c, C::static_id());
c.def(py::init<const std::string,
const Common::FieldMatrix<std::string, r, rC>,
const Common::FieldVector<Common::FieldMatrix<std::string, rC, d>, r>,
const size_t,
const std::string>(),
"variable"_a,
"expressions"_a,
"gradient_expressions"_a,
"order"_a,
"name"_a = C::static_id());
c.def(py::init<const std::string, const Common::FieldMatrix<std::string, r, rC>, const size_t, const std::string>(),
"variable"_a,
"expressions"_a,
"order"_a,
"name"_a = C::static_id());
c.def_property_readonly("static_id", [](const C& /*self*/) { return C::static_id(); });
const std::string make_name = "make_expression_function_" + Common::to_string(r) + "x" + Common::to_string(rC);
m.def(std::string(make_name).c_str(),
[](const std::string& variable,
const Common::FieldMatrix<std::string, r, rC>& expression,
const Common::FieldVector<Common::FieldMatrix<std::string, rC, d>, r>& gradient_expressions,
const size_t& order,
const std::string& name) { return C(variable, expression, gradient_expressions, order, name); },
"variable"_a,
"expression"_a,
"gradient_expressions"_a,
"order"_a,
"name"_a = C::static_id());
m.def(std::string(make_name).c_str(),
[](const std::string& variable,
const Common::FieldMatrix<std::string, r, rC>& expression,
const size_t& order,
const std::string& name) { return C(variable, expression, order, name); },
"variable"_a,
"expression"_a,
"order"_a,
"name"_a = C::static_id());
return c;
} // ... bind_ExpressionFunction(...)
template <size_t d, size_t r>
pybind11::class_<ExpressionFunction<d, r, 2, double>, FunctionInterface<d, r, 2, double>>
bind_ExpressionFunction(pybind11::module& m, std::integral_constant<int, 2>)
{
namespace py = pybind11;
using namespace pybind11::literals;
const size_t rC = 2;
using R = double;
using I = FunctionInterface<d, r, rC, R>;
using C = ExpressionFunction<d, r, rC, R>;
const std::string c_name =
"ExpressionFunction__" + Common::to_string(d) + "d_to_" + Common::to_string(r) + "x" + Common::to_string(rC);
py::class_<C, I> c(m, std::string(c_name).c_str(), std::string(c_name).c_str());
internal::addbind_ExpressionFunction_scalar_ctor<d, r, rC>()(c, C::static_id());
c.def(py::init<const std::string,
const Common::FieldMatrix<std::string, r, rC>,
const Common::FieldVector<Common::FieldMatrix<std::string, rC, d>, r>,
const size_t,
const std::string>(),
"variable"_a,
"expressions"_a,
"gradient_expressions"_a,
"order"_a,
"name"_a = C::static_id());
c.def(py::init<const std::string, const Common::FieldMatrix<std::string, r, rC>, const size_t, const std::string>(),
"variable"_a,
"expressions"_a,
"order"_a,
"name"_a = C::static_id());
c.def_property_readonly("static_id", [](const C& /*self*/) { return C::static_id(); });
const std::string make_name = "make_expression_function_" + Common::to_string(r) + "x" + Common::to_string(rC);
m.def(std::string(make_name).c_str(),
[](const std::string& variable,
const Common::FieldMatrix<std::string, r, rC>& expression,
const Common::FieldVector<Common::FieldMatrix<std::string, rC, d>, r>& gradient_expressions,
const size_t& order,
const std::string& name) { return C(variable, expression, gradient_expressions, order, name); },
"variable"_a,
"expression"_a,
"gradient_expressions"_a,
"order"_a,
"name"_a = C::static_id());
m.def(std::string(make_name).c_str(),
[](const std::string& variable,
const Common::FieldMatrix<std::string, r, rC>& expression,
const size_t& order,
const std::string& name) { return C(variable, expression, order, name); },
"variable"_a,
"expression"_a,
"order"_a,
"name"_a = C::static_id());
return c;
} // ... bind_ExpressionFunction(...)
template <size_t d, size_t r>
pybind11::class_<ExpressionFunction<d, r, 1, double>, FunctionInterface<d, r, 1, double>>
bind_ExpressionFunction(pybind11::module& m, std::integral_constant<int, 1>)
{
namespace py = pybind11;
using namespace pybind11::literals;
const size_t rC = 1;
using R = double;
using I = FunctionInterface<d, r, rC, R>;
using C = ExpressionFunction<d, r, rC, R>;
const std::string c_name =
"ExpressionFunction__" + Common::to_string(d) + "d_to_" + Common::to_string(r) + "x" + Common::to_string(1);
py::class_<C, I> c(m, std::string(c_name).c_str(), std::string(c_name).c_str());
internal::addbind_ExpressionFunction_scalar_ctor<d, r, 1>()(c, C::static_id());
c.def(py::init<const std::string,
const Common::FieldVector<std::string, r>,
const Common::FieldMatrix<std::string, r, d>,
const size_t,
const std::string>(),
"variable"_a,
"expressions"_a,
"gradient_expressions"_a,
"order"_a,
"name"_a = C::static_id());
c.def(py::init<const std::string, const Common::FieldVector<std::string, r>, const size_t, const std::string>(),
"variable"_a,
"expressions"_a,
"order"_a,
"name"_a = C::static_id());
c.def_property_readonly("static_id", [](const C& /*self*/) { return C::static_id(); });
const std::string make_name = "make_expression_function_" + Common::to_string(r) + "x" + Common::to_string(1);
m.def(std::string(make_name).c_str(),
[](const std::string& variable,
const Common::FieldVector<std::string, r>& expression,
const Common::FieldMatrix<std::string, r, d>& gradient_expressions,
const size_t& order,
const std::string& name) { return C(variable, expression, gradient_expressions, order, name); },
"variable"_a,
"expression"_a,
"gradient_expressions"_a,
"order"_a,
"name"_a = C::static_id());
m.def(std::string(make_name).c_str(),
[](const std::string& variable,
const Common::FieldVector<std::string, r>& expression,
const size_t& order,
const std::string& name) { return C(variable, expression, order, name); },
"variable"_a,
"expression"_a,
"order"_a,
"name"_a = C::static_id());
return c;
}
template <size_t d, size_t r, size_t rC>
pybind11::class_<ExpressionFunction<d, r, rC, double>> bind_ExpressionFunction(pybind11::module& m)
{
return bind_ExpressionFunction<d, r>(m, std::integral_constant<int, rC>());
} // ... bind_ExpressionFunction(...)
} // namespace Functions
} // namespace XT
} // namespace Dune
#endif // PYTHON_DUNE_XT_FUNCTIONS_EXPRESSION_HH
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment