/// Copyright (C) 2017 Chris N. Richardson and Garth N. Wells
//
// This file is part of DOLFIN.
//
// DOLFIN is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// DOLFIN is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with DOLFIN. If not, see .
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
namespace py = pybind11;
namespace dolfin_wrappers
{
void function(py::module& m)
{
// ufc::shape
py::class_(m, "ufc_shape");
// ufc::cell
py::class_>(m, "ufc_cell")
.def(py::init<>())
.def_readonly("cell_shape", &ufc::cell::cell_shape)
.def_readonly("topological_dimension", &ufc::cell::topological_dimension)
.def_readonly("geometric_dimension", &ufc::cell::geometric_dimension)
.def_readonly("local_facet", &ufc::cell::local_facet)
.def_readonly("mesh_identifier", &ufc::cell::mesh_identifier)
.def_readonly("index", &ufc::cell::index);
// ufc::function
py::class_>(m, "ufc_function");
// dolfin::GenericFunction
py::class_,
ufc::function, dolfin::Variable>
(m, "GenericFunction")
.def("value_dimension", &dolfin::GenericFunction::value_dimension)
.def("value_size", &dolfin::GenericFunction::value_size)
.def("value_rank", &dolfin::GenericFunction::value_rank)
.def_property_readonly("value_shape", &dolfin::GenericFunction::value_shape)
// FIXME: Change eval function to return NumPy array
// FIXME: Add C++ version that takes a dolfin::Cell
.def("eval", [](const dolfin::GenericFunction& self, Eigen::Ref u,
Eigen::Ref x, const dolfin::Cell& cell)
{
ufc::cell ufc_cell;
cell.get_cell_data(ufc_cell);
self.eval(u, x, ufc_cell);
}, "Evaluate GenericFunction (cell version)")
.def("eval", (void (dolfin::GenericFunction::*)(Eigen::Ref,
Eigen::Ref, const ufc::cell&) const)
&dolfin::GenericFunction::eval,
"Evaluate GenericFunction (cell version)")
.def("eval", (void (dolfin::GenericFunction::*)(Eigen::Ref,
Eigen::Ref) const)
&dolfin::GenericFunction::eval, py::arg("values"), py::arg("x"), "Evaluate GenericFunction")
.def("compute_vertex_values", [](dolfin::GenericFunction& self, const dolfin::Mesh& mesh)
{ std::vector values;
self.compute_vertex_values(values, mesh);
return py::array_t(values.size(), values.data());
}, "Compute values at all mesh vertices")
.def("compute_vertex_values", [](dolfin::GenericFunction& self)
{
auto V = self.function_space();
if (!V)
throw py::value_error("GenericFunction has no function space. You must supply a mesh.");
auto mesh = V->mesh();
if (!mesh)
throw py::value_error("GenericFunction has no function space mesh. You must supply a mesh.");
std::vector values;
self.compute_vertex_values(values, *mesh);
// FIXME: this causes a copy, we should rewrite the C++ interface to use Eigen when SWIG is removed
return py::array_t(values.size(), values.data());
}, "Compute values at all mesh vertices by using the mesh function.function_space().mesh()")
.def("function_space", &dolfin::GenericFunction::function_space)
.def("restrict", [](const dolfin::GenericFunction& self,
const dolfin::FiniteElement& element,
const dolfin::Cell& cell)
{
ufc::cell ufc_cell;
cell.get_cell_data(ufc_cell);
std::vector coordinate_dofs;
cell.get_coordinate_dofs(coordinate_dofs);
std::size_t s_dim = element.space_dimension();
Eigen::VectorXd w(s_dim);
self.restrict(w.data(), element, cell,
coordinate_dofs.data(), ufc_cell);
return w; // no copy
});
// Create dolfin::Expression from a JIT pointer
m.def("make_dolfin_expression",
[](std::uintptr_t e)
{
dolfin::Expression *p = reinterpret_cast(e);
return std::shared_ptr(p);
}, "Create a dolfin::Expression object from a pointer integer, typically returned by a just-in-time compiler");
// dolfin::Expression trampoline (used for overloading virtual
// function from Python)
class PyExpression : public dolfin::Expression
{
using dolfin::Expression::Expression;
void eval(Eigen::Ref values,
Eigen::Ref x) const override
{ PYBIND11_OVERLOAD(void, dolfin::Expression, eval, values, x); }
void eval(Eigen::Ref values,
Eigen::Ref x,
const ufc::cell& cell) const override
{ PYBIND11_OVERLOAD_NAME(void, dolfin::Expression, "eval_cell", eval, values, x, cell); }
};
// dolfin:Expression
py::class_,
dolfin::GenericFunction>(m, "Expression", "An Expression is a function (field) that can appear as a coefficient in a form")
.def(py::init<>())
.def(py::init())
.def(py::init())
.def(py::init>())
.def("__call__", [](const dolfin::Expression& self, Eigen::Ref x)
{
Eigen::VectorXd f(self.value_size());
self.eval(f, x);
return f;
})
.def("__call__", [](const dolfin::Expression& self, const dolfin::Point& p)
{
const Eigen::Map x(const_cast(p.coordinates()), 3);
Eigen::VectorXd f(self.value_size());
self.eval(f, x);
return f;
})
.def("value_dimension", &dolfin::Expression::value_dimension)
.def("get_property", &dolfin::Expression::get_property)
.def("set_property", [](dolfin::Expression& self, std::string name, py::object value)
{
if (py::isinstance(value))
{
auto _v = value.cast>();
self.set_generic_function(name, _v);
}
else if (py::hasattr(value, "_cpp_object"))
{
auto _v = value.attr("_cpp_object").cast>();
self.set_generic_function(name, _v);
}
else
{
double _v = value.cast();
self.set_property(name, _v);
}
})
.def("get_generic_function", &dolfin::Expression::get_generic_function);
// dolfin::Constant
py::class_, dolfin::Expression>
(m, "Constant")
.def(py::init())
.def(py::init>())
.def(py::init, std::vector>())
.def("values", [](const dolfin::Constant& self)
{ auto v = self.values(); return py::array_t(v.size(), v.data()); })
.def("__float__", [](const dolfin::Constant& instance) -> double { return instance; })
/*
.def("_assign", [](dolfin::Constant& self, const dolfin::Constant& other) -> const dolfin::Constant&
{self = other;})
.def("_assign", [](dolfin::Constant& self, double value) -> const dolfin::Constant&
{self = value;})
*/
.def("assign", [](dolfin::Constant& self, const dolfin::Constant& other) {self = other;})
.def("assign", [](dolfin::Constant& self, double value) {self = value;})
/*
.def("_assign", (const dolfin::Constant& (dolfin::Constant::*)(const dolfin::Constant&))
&dolfin::Constant::operator=)
.def("_assign", (const dolfin::Constant& (dolfin::Constant::*)(double))
&dolfin::Constant::operator=)
*/
.def("str", &dolfin::Constant::str);
// dolfin::FacetArea
py::class_,
dolfin::Expression, dolfin::GenericFunction>
(m, "FacetArea")
.def(py::init>());
// dolfin::MeshCoordinates
py::class_,
dolfin::Expression, dolfin::GenericFunction>
(m, "MeshCoordinates")
.def(py::init>());
// Hierarchical dolfin::Function
py::class_, std::shared_ptr>>
(m, "HierarchicalFunction", "some description")
.def("root_node", [](dolfin::Hierarchical& self)
{ return self.root_node_shared_ptr(); } )
.def("leaf_node", [](dolfin::Hierarchical& self)
{ return self.leaf_node_shared_ptr(); } );
//.def("root_node", &dolfin::Hierarchical::root_node_shared_ptr)
//.def("leaf_node", &dolfin::Hierarchical::leaf_node_shared_ptr);
// dolfin::Function
py::class_, dolfin::GenericFunction,
dolfin::Hierarchical>
(m, "Function", "A finite element function")
.def(py::init>(), "Create a function on the given function space")
.def(py::init, std::string>())
.def(py::init())
.def(py::init, std::shared_ptr>())
.def("_assign", (const dolfin::Function& (dolfin::Function::*)(const dolfin::Function&))
&dolfin::Function::operator=)
.def("_assign", (const dolfin::Function& (dolfin::Function::*)(const dolfin::Expression&))
&dolfin::Function::operator=)
.def("_assign", (void (dolfin::Function::*)(const dolfin::FunctionAXPY&))
&dolfin::Function::operator=)
.def("_in", &dolfin::Function::in)
.def("__call__", [](dolfin::Function& self, std::vector& p)
{
// FIXME - remove Array and replace with Eigen in DOLFIN
const dolfin::Array x(p.size(), p.data());
Eigen::VectorXd values(self.value_size());
dolfin::Array _values(self.value_size(), values.data());
self.eval(_values, x);
return values;
})
.def("extrapolate", &dolfin::Function::extrapolate)
.def("extrapolate", [](dolfin::Function& instance, const py::object v)
{
auto _v = v.attr("_cpp_object").cast();
instance.extrapolate(*_v);
})
.def("sub", &dolfin::Function::operator[])
.def("get_allow_extrapolation", &dolfin::Function::get_allow_extrapolation)
.def("interpolate", (void (dolfin::Function::*)(const dolfin::GenericFunction&))
&dolfin::Function::interpolate, "Interpolate the function u")
.def("interpolate", [](dolfin::Function& instance, const py::object v)
{
auto _v = v.attr("_cpp_object").cast();
instance.interpolate(*_v);
}, "Interpolate the function u")
.def("set_allow_extrapolation", &dolfin::Function::set_allow_extrapolation)
// FIXME: A lot of error when using non-const version - misused
// by Python interface?
.def("vector", (std::shared_ptr (dolfin::Function::*)() const)
&dolfin::Function::vector, "Return the vector associated with the finite element Function");
// FIXME: why is this floating here?
m.def("interpolate", [](const dolfin::GenericFunction& f,
std::shared_ptr V)
{
auto g = std::make_shared(V);
g->interpolate(f);
return g;
});
// dolfin::FunctionAXPY
py::class_> function_axpy(m, "FunctionAXPY");
function_axpy
.def(py::init, double>())
.def(py::init, std::shared_ptr,
dolfin::FunctionAXPY::Direction>())
.def(py::init>>>())
.def(py::init([](std::vector> fun)
{
std::vector>> a;
for (auto p : fun)
a.push_back({p.first, p.second.attr("_cpp_object").cast>()});
return dolfin::FunctionAXPY(a);
}))
.def(py::init([](py::object f1, double a)
{
auto _f1 = f1.attr("_cpp_object").cast>();
return dolfin::FunctionAXPY(_f1, a);
}))
.def(py::self + py::self)
.def(py::self + std::shared_ptr())
.def("__add__", [](dolfin::FunctionAXPY& self, py::object f1)
{
return (self + f1.attr("_cpp_object").cast>());
})
.def(py::self - py::self)
.def(py::self - std::shared_ptr())
.def("__sub__", [](dolfin::FunctionAXPY& self, py::object f1)
{
return (self - f1.attr("_cpp_object").cast>());
})
.def(py::self * float())
.def(py::self / float());
// dolfin::FunctionAXPY enum
py::enum_(function_axpy, "Direction")
.value("ADD_ADD", dolfin::FunctionAXPY::Direction::ADD_ADD)
.value("SUB_ADD", dolfin::FunctionAXPY::Direction::SUB_ADD)
.value("ADD_SUB", dolfin::FunctionAXPY::Direction::ADD_SUB)
.value("SUB_SUB", dolfin::FunctionAXPY::Direction::SUB_SUB);
// dolfin::FunctionSpace
py::class_, dolfin::Variable>
(m, "FunctionSpace", py::dynamic_attr())
.def(py::init, std::shared_ptr,
std::shared_ptr>())
.def(py::init())
.def("__eq__", &dolfin::FunctionSpace::operator==)
.def("dim", &dolfin::FunctionSpace::dim)
.def("collapse", [](dolfin::FunctionSpace& self)
{
std::unordered_map dofs;
auto V = self.collapse(dofs);
return std::pair, std::unordered_map>({V, dofs});
})
.def("component", &dolfin::FunctionSpace::component)
.def("contains", &dolfin::FunctionSpace::contains)
.def("element", &dolfin::FunctionSpace::element)
.def("mesh", &dolfin::FunctionSpace::mesh)
.def("dofmap", &dolfin::FunctionSpace::dofmap)
.def("set_x", &dolfin::FunctionSpace::set_x)
.def("sub", (std::shared_ptr (dolfin::FunctionSpace::*)(std::size_t) const)
&dolfin::FunctionSpace::sub)
.def("extract_sub_space", &dolfin::FunctionSpace::extract_sub_space)
.def("tabulate_dof_coordinates", [](const dolfin::FunctionSpace& self)
{
const std::size_t gdim = self.element()->geometric_dimension();
std::vector coords = self.tabulate_dof_coordinates();
assert(coords.size() % gdim == 0);
py::array_t c({coords.size()/gdim, gdim}, coords.data() );
return c;
});
// dolfin::LagrangeInterpolator
py::class_ (m, "LagrangeInterpolator")
.def_static("interpolate", (void (*)(dolfin::Function&, const dolfin::Function&))
&dolfin::LagrangeInterpolator::interpolate)
.def_static("interpolate", [](py::object f1, py::object f2)
{
auto _f1 = f1.attr("_cpp_object").cast();
auto _f2cpp = f2.attr("_cpp_object");
if (py::isinstance(_f2cpp))
{
auto _f2 = _f2cpp.cast();
dolfin::LagrangeInterpolator::interpolate(*_f1, *_f2);
}
else if (py::isinstance(_f2cpp))
{
auto _f2 = _f2cpp.cast();
dolfin::LagrangeInterpolator::interpolate(*_f1, *_f2);
}
else
throw py::type_error("Can only interpolate Expression or Function");
});
// dolfin::FunctionAssigner
py::class_>
(m, "FunctionAssigner")
.def(py::init,
std::shared_ptr>())
.def(py::init>,
std::shared_ptr>())
.def(py::init,
std::vector>>())
.def(py::init([](py::object V0, py::object V1)
{
if (py::isinstance(V0))
{
std::vector> _V0;
for (auto V : py::cast(V0))
_V0.push_back(V.attr("_cpp_object").cast>());
auto _V1 = V1.attr("_cpp_object").cast>();
return dolfin::FunctionAssigner(_V0, _V1);
}
else if (py::isinstance(V1))
{
std::vector> _V1;
for (auto V : py::cast(V1))
_V1.push_back(V.attr("_cpp_object").cast>());
auto _V0 = V0.attr("_cpp_object").cast>();
return dolfin::FunctionAssigner(_V0, _V1);
}
else
{
auto _V0 = V0.attr("_cpp_object").cast>();
auto _V1 = V1.attr("_cpp_object").cast>();
return dolfin::FunctionAssigner(_V0, _V1);
}
}))
.def("assign", (void (dolfin::FunctionAssigner::*)(std::shared_ptr,
std::shared_ptr) const)
&dolfin::FunctionAssigner::assign)
.def("assign", [](const dolfin::FunctionAssigner& self, py::object v0, py::object v1)
{
if (py::isinstance(v0))
{
std::vector> _v0;
for (auto v : py::cast(v0))
_v0.push_back(v.attr("_cpp_object").cast>());
auto _v1 = v1.attr("_cpp_object").cast>();
self.assign(_v0, _v1);
return;
}
else if (py::isinstance(v1))
{
auto _v0 = v0.attr("_cpp_object").cast>();
std::vector> _v1;
for (auto v : py::cast(v1))
_v1.push_back(v.attr("_cpp_object").cast>());
self.assign(_v0, _v1);
return;
}
else
{
auto _v0 = v0.attr("_cpp_object").cast>();
auto _v1 = v1.attr("_cpp_object").cast>();
self.assign(_v0, _v1);
return;
}
});
py::class_, dolfin::Variable>(m, "MultiMeshFunction")
.def(py::init>())
.def("vector", static_cast(dolfin::MultiMeshFunction::*)()>(&dolfin::MultiMeshFunction::vector))
.def("part", (std::shared_ptr (dolfin::MultiMeshFunction::*)(std::size_t) const)&dolfin::MultiMeshFunction::part)
.def("part", (std::shared_ptr (dolfin::MultiMeshFunction::*)(std::size_t, bool) const)&dolfin::MultiMeshFunction::part)
.def("assign_part", (void (dolfin::MultiMeshFunction::*)(std::size_t, const dolfin::Function)) &dolfin::MultiMeshFunction::assign_part);
py::class_>
(m, "MultiMeshFunctionSpace", py::dynamic_attr())
.def(py::init>())
.def("add", [](dolfin::MultiMeshFunctionSpace& self, py::object v0)
{
auto _v0 = v0.attr("_cpp_object").cast>();
self.add(_v0);
return;
})
.def("num_parts", &dolfin::MultiMeshFunctionSpace::num_parts)
.def("build", static_cast(&dolfin::MultiMeshFunctionSpace::build))
.def("multimesh", &dolfin::MultiMeshFunctionSpace::multimesh)
.def("part", &dolfin::MultiMeshFunctionSpace::part)
.def("lock_inactive_dofs", &dolfin::MultiMeshFunctionSpace::lock_inactive_dofs)
.def("dofmap", &dolfin::MultiMeshFunctionSpace::dofmap)
.def("dim", &dolfin::MultiMeshFunctionSpace::dim);
// dolfin::assign interface
m.def("assign", [](py::object v0, py::object v1)
{
if (py::isinstance(v0))
{
std::vector> _v0;
for (auto v : py::cast(v0))
_v0.push_back(v.attr("_cpp_object").cast>());
auto _v1 = v1.attr("_cpp_object").cast>();
dolfin::assign(_v0, _v1);
return;
}
else if (py::isinstance(v1))
{
auto _v0 = v0.attr("_cpp_object").cast>();
std::vector> _v1;
for (auto v : py::cast(v1))
_v1.push_back(v.attr("_cpp_object").cast>());
dolfin::assign(_v0, _v1);
return;
}
else
{
auto _v0 = v0.attr("_cpp_object").cast>();
auto _v1 = v1.attr("_cpp_object").cast>();
dolfin::assign(_v0, _v1);
return;
}
});
py::class_, dolfin::MultiMeshFunctionSpace>(m, "MultiMeshSubSpace")
.def(py::init())
.def(py::init>())
.def(py::init([](py::object function_space, std::size_t i)
{
auto f_s = function_space.attr("_cpp_object").cast();
return dolfin::MultiMeshSubSpace(f_s, i);
}
));
}
}