// Copyright (C) 2017 Chris 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
#ifdef HAS_PYBIND11_PETSC4PY
#include
#endif
#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
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include "casters.h"
namespace py = pybind11;
namespace dolfin_wrappers
{
void fem(py::module& m)
{
// UFC objects
py::class_>
(m, "ufc_finite_element", "UFC finite element object");
py::class_>
(m, "ufc_dofmap", "UFC dofmap object");
py::class_>
(m, "ufc_form", "UFC form object");
// Adapt functions
m.def("adapt", [](dolfin::Mesh mesh){return dolfin::adapt(mesh);},
"Mapping between parent and child entities has to be set in refined mesh. See various refinement algorithms and `parameters['refinement_algorithm']`.");
m.def("adapt", [](const dolfin::MeshFunction& mesh_function,
std::shared_ptr adapted_mesh)
{
return dolfin::adapt(mesh_function, adapted_mesh);});
// Function to convert pointers (from JIT usually) to UFC objects
m.def("make_ufc_finite_element",
[](std::uintptr_t e)
{
ufc::finite_element * p = reinterpret_cast(e);
return std::shared_ptr(p);
});
m.def("make_ufc_dofmap",
[](std::uintptr_t e)
{
ufc::dofmap * p = reinterpret_cast(e);
return std::shared_ptr(p);
});
m.def("make_ufc_form",
[](std::uintptr_t e)
{
ufc::form * p = reinterpret_cast(e);
return std::shared_ptr(p);
});
// dolfin::FiniteElement
py::class_>
(m, "FiniteElement", "DOLFIN FiniteElement object")
.def(py::init>())
.def("num_sub_elements", &dolfin::FiniteElement::num_sub_elements)
.def("evaluate_dofs", [](const dolfin::FiniteElement& self, py::object f,
py::array_t coordinate_dofs,
int cell_orientation, const dolfin::Cell& c)
{
const ufc::function* _f = nullptr;
if (py::hasattr(f, "_cpp_object"))
_f = f.attr("_cpp_object").cast();
else
_f = f.cast();
ufc::cell ufc_cell;
c.get_cell_data(ufc_cell);
py::array_t dofs(self.space_dimension());
self.evaluate_dofs(dofs.mutable_data(), *_f,
coordinate_dofs.data(), cell_orientation, ufc_cell);
return dofs;
}, "Evaluate degrees of freedom on element for a given function")
.def("tabulate_dof_coordinates", [](const dolfin::FiniteElement& self, const dolfin::Cell& cell)
{
// Get cell vertex coordinates
std::vector coordinate_dofs;
cell.get_coordinate_dofs(coordinate_dofs);
// Tabulate the coordinates
boost::multi_array _dof_coords;
self.tabulate_dof_coordinates(_dof_coords, coordinate_dofs, cell);
// Copy data and return
typedef Eigen::Array EigenArray;
EigenArray dof_coords = Eigen::Map(_dof_coords.data(),
_dof_coords.shape()[0],
_dof_coords.shape()[1]);
return dof_coords;
}, "Tabulate coordinates of dofs on cell")
.def("evaluate_basis", [](const dolfin::FiniteElement& self, int i,
const py::array_t x,
const py::array_t coordinate_dofs,
int cell_orientation)
{
auto ufc_element = self.ufc_element();
const std::size_t size = ufc_element->value_size();
py::array_t values(size);
self.evaluate_basis(i, values.mutable_data(), x.data(), coordinate_dofs.data(),
cell_orientation);
return values;
}, "Evaluate basis function i at given point x in cell.")
.def("evaluate_basis_all", [](const dolfin::FiniteElement& self,
const py::array_t x,
const py::array_t coordinate_dofs,
int cell_orientation)
{
auto ufc_element = self.ufc_element();
const std::size_t size = ufc_element->value_size();
const std::size_t space_dimension = ufc_element->space_dimension();
py::array_t values(space_dimension*size);
self.evaluate_basis_all(values.mutable_data(), x.data(), coordinate_dofs.data(),
cell_orientation);
return values;
}, "Evaluate order n derivatives of all basis functions at given point x in cell.")
.def("evaluate_basis_derivatives", [](const dolfin::FiniteElement& self,
int i, int order,
const py::array_t x,
const py::array_t coordinate_dofs,
int cell_orientation)
{
auto ufc_element = self.ufc_element();
const std::size_t gdim = self.geometric_dimension();
const std::size_t num_derivs = pow(gdim, order);
const std::size_t size = ufc_element->value_size()*num_derivs;
py::array_t values(size);
self.evaluate_basis_derivatives(i, order, values.mutable_data(),
x.data(), coordinate_dofs.data(),
cell_orientation);
return values;
}, "Evaluate order n derivatives of basis function i at given point x in cell.")
.def("evaluate_basis_derivatives_all", [](const dolfin::FiniteElement& self,
int order,
const py::array_t x,
const py::array_t coordinate_dofs,
int cell_orientation)
{
auto ufc_element = self.ufc_element();
const std::size_t gdim = self.geometric_dimension();
const std::size_t num_derivs = pow(gdim, order);
const std::size_t size = ufc_element->value_size()*num_derivs;
const std::size_t space_dimension = ufc_element->space_dimension();
py::array_t values(size*space_dimension);
self.evaluate_basis_derivatives_all(order, values.mutable_data(),
x.data(), coordinate_dofs.data(),
cell_orientation);
return values;
}, "Evaluate all basis functions at given point x in cell.")
.def("space_dimension", &dolfin::FiniteElement::space_dimension)
.def("geometric_dimension", &dolfin::FiniteElement::geometric_dimension)
.def("value_dimension", &dolfin::FiniteElement::value_dimension)
.def("signature", &dolfin::FiniteElement::signature);
// dolfin::GenericDofMap
py::class_, dolfin::Variable>
(m, "GenericDofMap", "DOLFIN DofMap object")
.def("global_dimension", &dolfin::GenericDofMap::global_dimension,
"The dimension of the global finite element function space")
.def("index_map", &dolfin::GenericDofMap::index_map)
.def("neighbours", &dolfin::GenericDofMap::neighbours)
.def("off_process_owner", &dolfin::GenericDofMap::off_process_owner)
.def("shared_nodes", &dolfin::GenericDofMap::shared_nodes)
.def("cell_dofs", &dolfin::GenericDofMap::cell_dofs)
.def("dofs", (std::vector(dolfin::GenericDofMap::*)() const)
&dolfin::GenericDofMap::dofs)
.def("dofs", (std::vector(dolfin::GenericDofMap::*)(const dolfin::Mesh&, std::size_t) const)
&dolfin::GenericDofMap::dofs)
.def("entity_dofs", (std::vector(dolfin::GenericDofMap::*)(const dolfin::Mesh&, std::size_t) const)
&dolfin::GenericDofMap::entity_dofs)
.def("entity_closure_dofs", (std::vector(dolfin::GenericDofMap::*)(const dolfin::Mesh&, std::size_t) const)
&dolfin::GenericDofMap::entity_closure_dofs)
.def("entity_dofs", (std::vector(dolfin::GenericDofMap::*)(const dolfin::Mesh&,
std::size_t,
const std::vector&) const)
&dolfin::GenericDofMap::entity_dofs)
.def("entity_closure_dofs", (std::vector(dolfin::GenericDofMap::*)(const dolfin::Mesh&,
std::size_t,
const std::vector&) const)
&dolfin::GenericDofMap::entity_closure_dofs)
.def("num_entity_dofs", &dolfin::GenericDofMap::num_entity_dofs)
.def("tabulate_local_to_global_dofs", &dolfin::GenericDofMap::tabulate_local_to_global_dofs)
.def("local_to_global_index", &dolfin::GenericDofMap::local_to_global_index)
.def("local_to_global_unowned",
[](dolfin::GenericDofMap& self) {
return Eigen::Map>(
self.local_to_global_unowned().data(),
self.local_to_global_unowned().size()); },
py::return_value_policy::reference_internal,
"Return view into unowned part of local-to-global map")
.def("clear_sub_map_data", &dolfin::GenericDofMap::clear_sub_map_data)
.def("tabulate_entity_dofs", [](const dolfin::GenericDofMap& instance, std::size_t entity_dim,
std::size_t cell_entity_index)
{
std::vector dofs(instance.num_entity_dofs(entity_dim));
instance.tabulate_entity_dofs(dofs, entity_dim, cell_entity_index);
return py::array_t(dofs.size(), dofs.data());
})
.def("block_size", &dolfin::GenericDofMap::block_size)
.def("tabulate_local_to_global_dofs", [](const dolfin::GenericDofMap& instance)
{
std::vector dofs;
instance.tabulate_local_to_global_dofs(dofs);
return py::array_t(dofs.size(), dofs.data());
})
.def("set", &dolfin::GenericDofMap::set)
.def_readonly("constrained_domain", &dolfin::GenericDofMap::constrained_domain);
// dolfin::DofMap
py::class_, dolfin::GenericDofMap>
(m, "DofMap", "DOLFIN DofMap object")
.def(py::init, const dolfin::Mesh&>())
.def(py::init, const dolfin::Mesh&, std::shared_ptr>())
.def("ownership_range", &dolfin::DofMap::ownership_range)
.def("cell_dofs", &dolfin::DofMap::cell_dofs);
// dolfin::MultiMeshDofMap
py::class_>
(m, "MultiMeshDofMap", "DOLFIN MultiMeshDofMap object")
.def(py::init())
.def("inactive_dofs", &dolfin::MultiMeshDofMap::inactive_dofs);
// dolfin::SparsityPatternBuilder
py::class_(m, "SparsityPatternBuilder")
.def_static("build", &dolfin::SparsityPatternBuilder::build,
py::arg("sparsity_pattern"), py::arg("mesh"),
py::arg("dofmaps"), py::arg("cells"),
py::arg("interior_facets"), py::arg("exterior_facets"),
py::arg("vertices"), py::arg("diagonal"),
py::arg("init")=true, py::arg("finalize")=true)
.def_static("build", &dolfin::SparsityPatternBuilder::build_mixed,
py::arg("sparsity_pattern"), py::arg("mesh_ids"), py::arg("mesh"),
py::arg("dofmaps"), py::arg("cells"),
py::arg("interior_facets"), py::arg("exterior_facets"),
py::arg("vertices"), py::arg("diagonal"),
py::arg("init")=true, py::arg("finalize")=true);
// dolfin::DirichletBC
py::class_, dolfin::Variable>
(m, "DirichletBC", "DOLFIN DirichletBC object")
.def(py::init())
.def(py::init,
std::shared_ptr,
std::shared_ptr, std::string, bool>(),
py::arg("V"), py::arg("g"), py::arg("sub_domain"),
py::arg("method")="topological", py::arg("check_midpoint")=true)
.def(py::init,
std::shared_ptr,
std::shared_ptr>,
std::size_t, std::string>(),
py::arg("V"), py::arg("g"), py::arg("sub_domains"),
py::arg("sub_domain"), py::arg("method")="topological")
.def("function_space", &dolfin::DirichletBC::function_space)
.def("homogenize", &dolfin::DirichletBC::homogenize)
.def("method", &dolfin::DirichletBC::method)
.def("zero", &dolfin::DirichletBC::zero)
.def("markers", &dolfin::DirichletBC::markers)
.def("zero_columns", &dolfin::DirichletBC::zero_columns,
py::arg("A"), py::arg("b"), py::arg("diagonal_value")=0.0, py::arg("transpose")=false)
.def("get_boundary_values", [](const dolfin::DirichletBC& instance)
{
dolfin::DirichletBC::Map map;
instance.get_boundary_values(map);
return map;
})
.def("apply", (void (dolfin::DirichletBC::*)(dolfin::GenericVector&) const)
&dolfin::DirichletBC::apply)
.def("apply", (void (dolfin::DirichletBC::*)(dolfin::GenericMatrix&) const)
&dolfin::DirichletBC::apply)
.def("apply", (void (dolfin::DirichletBC::*)(dolfin::GenericMatrix&, dolfin::GenericVector&) const)
&dolfin::DirichletBC::apply)
.def("apply", (void (dolfin::DirichletBC::*)(dolfin::GenericVector&, const dolfin::GenericVector&) const)
&dolfin::DirichletBC::apply)
.def("apply", (void (dolfin::DirichletBC::*)(dolfin::GenericMatrix&, dolfin::GenericVector&, const dolfin::GenericVector&) const)
&dolfin::DirichletBC::apply)
.def("user_sub_domain", &dolfin::DirichletBC::user_sub_domain)
.def("set_value", &dolfin::DirichletBC::set_value)
.def("set_value", [](dolfin::DirichletBC& self, py::object value)
{
auto _u = value.attr("_cpp_object").cast>();
self.set_value(_u);
})
.def("value", &dolfin::DirichletBC::value);
// dolfin::MultiMeshDirichletBC
py::class_>
(m, "MultiMeshDirichletBC", "DOLFIN MultiMeshDirichletBC object")
.def(py::init())
// Need to handle FunctionSpace and SubDomain coming from the Python layer
// Probably better to make Python class for it similar to DirichletBC
.def(py::init([](std::shared_ptr V,
py::object g, std::shared_ptr subdomain,
std::string method, bool check_midpoint,
bool exclude_overlapped_boundaries)
{
std::shared_ptr _g;
if (py::hasattr(g, "_cpp_object"))
_g = g.attr("_cpp_object").cast>();
else
_g = g.cast>();
return dolfin::MultiMeshDirichletBC(V, _g, subdomain, method,
check_midpoint, exclude_overlapped_boundaries);
}), py::arg("V"), py::arg("g"), py::arg("subdomain"),
py::arg("method")="topological",
py::arg("check_midpoint")=true,
py::arg("exclude_overlapped_boundaries")=true)
.def(py::init,
std::shared_ptr,
std::shared_ptr, std::string, bool, bool>(),
py::arg("V"), py::arg("g"), py::arg("sub_domain"),
py::arg("method")="topological", py::arg("check_midpoint")=true,
py::arg("exclude_overlapped_boundaries")=true)
.def(py::init,
std::shared_ptr,
std::shared_ptr>,
std::size_t, std::size_t, std::string>(),
py::arg("V"), py::arg("g"), py::arg("sub_domains"),
py::arg("sub_domain"), py::arg("part"), py::arg("method")="topological")
.def(py::init,
std::shared_ptr,
std::shared_ptr, std::size_t, std::string, bool, bool>(),
py::arg("V"), py::arg("g"), py::arg("sub_domain"), py::arg("part"),
py::arg("method")="topological", py::arg("check_midpoint")=true,
py::arg("exclude_overlapped_boundaries")=true)
.def("function_space", &dolfin::MultiMeshDirichletBC::function_space)
.def("homogenize", &dolfin::MultiMeshDirichletBC::homogenize)
.def("zero", &dolfin::MultiMeshDirichletBC::zero)
.def("apply", (void (dolfin::MultiMeshDirichletBC::*)(dolfin::GenericVector&) const)
&dolfin::MultiMeshDirichletBC::apply)
.def("apply", (void (dolfin::MultiMeshDirichletBC::*)(dolfin::GenericMatrix&) const)
&dolfin::MultiMeshDirichletBC::apply)
.def("apply", (void (dolfin::MultiMeshDirichletBC::*)(dolfin::GenericMatrix&, dolfin::GenericVector&) const)
&dolfin::MultiMeshDirichletBC::apply)
.def("apply", (void (dolfin::MultiMeshDirichletBC::*)(dolfin::GenericVector&, const dolfin::GenericVector&) const)
&dolfin::MultiMeshDirichletBC::apply)
.def("apply", (void (dolfin::MultiMeshDirichletBC::*)(dolfin::GenericMatrix&, dolfin::GenericVector&, const dolfin::GenericVector&) const)
&dolfin::MultiMeshDirichletBC::apply);
// dolfin::AssemblerBase
py::class_>
(m, "AssemblerBase")
.def("init_global_tensor", &dolfin::AssemblerBase::init_global_tensor)
.def_readwrite("add_values", &dolfin::Assembler::add_values)
.def_readwrite("keep_diagonal", &dolfin::Assembler::keep_diagonal)
.def_readwrite("finalize_tensor", &dolfin::Assembler::finalize_tensor);
// dolfin::Assembler
py::class_, dolfin::AssemblerBase>
(m, "Assembler", "DOLFIN Assembler object")
.def(py::init<>())
.def("assemble", &dolfin::Assembler::assemble);
// dolfin::MixedAssembler
py::class_, dolfin::AssemblerBase>
(m, "MixedAssembler", "DOLFIN MixedAssembler object")
.def(py::init<>())
.def("assemble", &dolfin::MixedAssembler::assemble);
// dolfin::SystemAssembler
py::class_, dolfin::AssemblerBase>
(m, "SystemAssembler", "DOLFIN SystemAssembler object")
.def(py::init, std::shared_ptr,
std::vector>>())
.def(py::init>, std::vector>,
std::vector>>>())
.def("assemble", (void (dolfin::SystemAssembler::*)(dolfin::GenericMatrix&, dolfin::GenericVector&))
&dolfin::SystemAssembler::assemble)
.def("assemble", (void (dolfin::SystemAssembler::*)(std::vector>, std::vector>))
&dolfin::SystemAssembler::assemble)
.def("assemble", (void (dolfin::SystemAssembler::*)(dolfin::GenericMatrix&)) &dolfin::SystemAssembler::assemble)
.def("assemble", (void (dolfin::SystemAssembler::*)(dolfin::GenericVector&)) &dolfin::SystemAssembler::assemble)
.def("assemble", (void (dolfin::SystemAssembler::*)(dolfin::GenericMatrix&, dolfin::GenericVector&,
const dolfin::GenericVector&))
&dolfin::SystemAssembler::assemble)
.def("assemble", (void (dolfin::SystemAssembler::*)(dolfin::GenericVector&, const dolfin::GenericVector&))
&dolfin::SystemAssembler::assemble);
// dolfin::DiscreteOperators
py::class_ (m, "DiscreteOperators")
.def_static("build_gradient", &dolfin::DiscreteOperators::build_gradient)
.def_static("build_gradient", [](py::object V0, py::object V1)
{
auto _V0 = V0.attr("_cpp_object").cast();
auto _V1 = V1.attr("_cpp_object").cast();
return dolfin::DiscreteOperators::build_gradient(*_V0, *_V1);
});
// dolfin::Form
py::class_>
(m, "Form", "DOLFIN Form object")
.def(py::init())
.def(py::init,
std::vector>>())
.def(py::init())
.def("function_spaces", &dolfin::Form::function_spaces, "Return function spaces for arguments")
.def("function_space", &dolfin::Form::function_space, "Return function space for i-th argument")
.def("num_coefficients", &dolfin::Form::num_coefficients, "Return number of coefficients in form")
.def("original_coefficient_position", &dolfin::Form::original_coefficient_position)
.def("set_coefficient", (void (dolfin::Form::*)(std::size_t, std::shared_ptr))
&dolfin::Form::set_coefficient, "Doc")
.def("set_coefficient", (void (dolfin::Form::*)(std::string, std::shared_ptr))
&dolfin::Form::set_coefficient, "Doc")
.def("set_mesh", &dolfin::Form::set_mesh)
.def("set_cell_domains", &dolfin::Form::set_cell_domains)
.def("set_exterior_facet_domains", &dolfin::Form::set_exterior_facet_domains)
.def("set_interior_facet_domains", &dolfin::Form::set_interior_facet_domains)
.def("set_vertex_domains", &dolfin::Form::set_vertex_domains)
.def("rank", &dolfin::Form::rank)
.def("mesh", &dolfin::Form::mesh);
// dolfin::MultiMeshForm
py::class_>
(m, "MultiMeshForm", "DOLFIN MultiForm object")
.def(py::init>())
.def(py::init>())
.def(py::init,
std::shared_ptr>())
.def("add", &dolfin::MultiMeshForm::add)
.def("build", &dolfin::MultiMeshForm::build)
.def("set_multimesh_coefficient", &dolfin::MultiMeshForm::set_multimesh_coefficient);
;
// dolfin::MultiMeshAssembler
py::class_>
(m, "MultiMeshAssembler", "DOLFIN MultiMeshAssembler object")
.def(py::init<>())
.def("assemble", &dolfin::MultiMeshAssembler::assemble);
// dolfin::PointSource
py::class_>
(m, "PointSource")
// FIXME: consolidate down to one intialiser when switching from
// SWIG to pybind11
.def(py::init([](py::object V, const dolfin::Point& p, double value)
{
std::shared_ptr _V;
if (py::hasattr(V, "_cpp_object"))
_V = V.attr("_cpp_object").cast>();
else
_V = V.cast>();
return dolfin::PointSource(_V, p, value);
}), py::arg("V"), py::arg("p"), py::arg("value"))
.def(py::init([](py::object V0, py::object V1, const dolfin::Point& p, double value)
{
std::shared_ptr _V0, _V1;
if (py::hasattr(V0, "_cpp_object"))
_V0 = V0.attr("_cpp_object").cast>();
else
_V0 = V0.cast>();
if (py::hasattr(V1, "_cpp_object"))
_V1 = V1.attr("_cpp_object").cast>();
else
_V1 = V1.cast>();
return dolfin::PointSource(_V0, _V1, p, value);
}), py::arg("V0"), py::arg("V1"), py::arg("p"), py::arg("value"))
.def(py::init([](py::object V, const std::vector> values)
{
std::shared_ptr _V;
if (py::hasattr(V, "_cpp_object"))
_V = V.attr("_cpp_object").cast>();
else
_V = V.cast>();
return dolfin::PointSource(_V, values);
}), py::arg("V"), py::arg("values"))
.def(py::init([](py::object V0, py::object V1, const std::vector> values)
{
std::shared_ptr _V0, _V1;
if (py::hasattr(V0, "_cpp_object"))
_V0 = V0.attr("_cpp_object").cast>();
else
_V0 = V0.cast>();
if (py::hasattr(V1, "_cpp_object"))
_V1 = V1.attr("_cpp_object").cast>();
else
_V1 = V1.cast>();
return dolfin::PointSource(_V0, _V1, values);
}), py::arg("V0"), py::arg("V1"), py::arg("values"))
//
//.def(py::init, const dolfin::Point&, double>(),
// py::arg("V"), py::arg("p"), py::arg("value"))
//.def(py::init, std::shared_ptr, const dolfin::Point&, double>(),
// py::arg("V0"), py::arg("V1"), py::arg("p"), py::arg("value"))
//.def(py::init, const std::vector>>())
//.def(py::init, std::shared_ptr,
// const std::vector>>())
.def("apply", (void (dolfin::PointSource::*)(dolfin::GenericVector&)) &dolfin::PointSource::apply)
.def("apply", (void (dolfin::PointSource::*)(dolfin::GenericMatrix&)) &dolfin::PointSource::apply);
// dolfin::LinearVariationalProblem
py::class_>
(m, "LinearVariationalProblem")
.def(py::init,
std::shared_ptr,
std::shared_ptr,
std::vector>>())
.def("bcs", &dolfin::LinearVariationalProblem::bcs);
// dolfin::LinearVariationalSolver
py::class_,
dolfin::Variable>(m, "LinearVariationalSolver")
.def(py::init>())
.def("solve", &dolfin::LinearVariationalSolver::solve)
.def("default_parameters", &dolfin::LinearVariationalSolver::default_parameters);
// dolfin::MixedLinearVariationalProblem
py::class_>
(m, "MixedLinearVariationalProblem")
.def(py::init>>,
std::vector>>,
std::vector>,
std::vector>>())
.def("bcs", (std::vector>
(dolfin::MixedLinearVariationalProblem::*)(int) const) &dolfin::MixedLinearVariationalProblem::bcs)
.def("bcs", (std::vector>>
(dolfin::MixedLinearVariationalProblem::*)() const) &dolfin::MixedLinearVariationalProblem::bcs);
// dolfin::MixedLinearVariationalSolver
py::class_,
dolfin::Variable>(m, "MixedLinearVariationalSolver")
.def(py::init<>())
.def(py::init>())
.def("solve", (void (dolfin::MixedLinearVariationalSolver::*)())&dolfin::MixedLinearVariationalSolver::solve)
.def("solve", (void (dolfin::MixedLinearVariationalSolver::*)
(std::tuple>,
std::vector>,
std::vector> >))&dolfin::MixedLinearVariationalSolver::solve)
.def("assemble_system", (std::tuple>,
std::vector>,
std::vector> >
(dolfin::MixedLinearVariationalSolver::*)()) &dolfin::MixedLinearVariationalSolver::assemble_system);
// dolfin::NonlinearVariationalProblem
py::class_>
(m, "NonlinearVariationalProblem")
.def(py::init,
std::shared_ptr,
std::vector>,
std::shared_ptr>())
// FIXME: is there a better way to handle the casting
.def("set_bounds", (void (dolfin::NonlinearVariationalProblem::*)(std::shared_ptr,
std::shared_ptr))
&dolfin::NonlinearVariationalProblem::set_bounds)
.def("set_bounds", (void (dolfin::NonlinearVariationalProblem::*)(const dolfin::Function&, const dolfin::Function&))
&dolfin::NonlinearVariationalProblem::set_bounds)
.def("set_bounds", [](dolfin::NonlinearVariationalProblem& self, py::object lb, py::object ub)
{
auto& _lb = lb.attr("_cpp_object").cast();
auto& _ub = ub.attr("_cpp_object").cast();
self.set_bounds(_lb, _ub);
});
// dolfin::NonlinearVariationalSolver
py::class_,
dolfin::Variable>
(m, "NonlinearVariationalSolver")
.def(py::init>())
.def("solve", &dolfin::NonlinearVariationalSolver::solve)
.def("default_parameters", &dolfin::NonlinearVariationalSolver::default_parameters);
// dolfin::MixedNonlinearVariationalProblem
py::class_>
(m, "MixedNonlinearVariationalProblem")
.def(py::init>>,
std::vector>,
std::vector>,
std::vector>>>())
.def("bcs", (std::vector>
(dolfin::MixedNonlinearVariationalProblem::*)(int) const) &dolfin::MixedNonlinearVariationalProblem::bcs)
.def("bcs", (std::vector>>
(dolfin::MixedNonlinearVariationalProblem::*)() const) &dolfin::MixedNonlinearVariationalProblem::bcs);
// dolfin::MixedNonlinearVariationalSolver
py::class_,
dolfin::Variable>(m, "MixedNonlinearVariationalSolver")
.def(py::init>())
.def("solve", &dolfin::MixedNonlinearVariationalSolver::solve);
// dolfin::LocalSolver
py::class_>
local_solver(m, "LocalSolver");
// dolfin::LocalSolver enums
py::enum_(local_solver, "SolverType")
.value("LU", dolfin::LocalSolver::SolverType::LU)
.value("Cholesky", dolfin::LocalSolver::SolverType::Cholesky);
local_solver.def(py::init,
std::shared_ptr,
dolfin::LocalSolver::SolverType>())
.def(py::init,
dolfin::LocalSolver::SolverType>())
.def("factorize", &dolfin::LocalSolver::factorize)
.def("clear_factorization", &dolfin::LocalSolver::clear_factorization)
.def("solve_local", &dolfin::LocalSolver::solve_local)
.def("solve_local_rhs", &dolfin::LocalSolver::solve_local_rhs)
.def("solve_global_rhs", &dolfin::LocalSolver::solve_global_rhs)
.def("solve_local_rhs", [](dolfin::LocalSolver& self, py::object u)
{
auto _u = u.attr("_cpp_object").cast();
self.solve_local_rhs(*_u);
})
.def("solve_global_rhs", [](dolfin::LocalSolver& self, py::object u)
{
auto _u = u.attr("_cpp_object").cast();
self.solve_global_rhs(*_u);
});
#ifdef HAS_PETSC
// dolfin::PETScDMCollection
py::class_>
(m, "PETScDMCollection")
.def(py::init>>())
.def(py::init([](py::list V)
{
std::vector> _V;
for (auto space : V)
{
auto _space = space.attr("_cpp_object").cast>();
_V.push_back(_space);
}
return dolfin::PETScDMCollection(_V);
}))
.def_static("create_transfer_matrix", &dolfin::PETScDMCollection::create_transfer_matrix)
.def_static("create_transfer_matrix", [](py::object V_coarse, py::object V_fine)
{
auto _V0 = V_coarse.attr("_cpp_object").cast();
auto _V1 = V_fine.attr("_cpp_object").cast();
return dolfin::PETScDMCollection::create_transfer_matrix(*_V0, *_V1);
})
.def("check_ref_count", &dolfin::PETScDMCollection::check_ref_count)
.def("get_dm", &dolfin::PETScDMCollection::get_dm);
#endif
// Assemble free functions
m.def("assemble", (void (*)(dolfin::GenericTensor&, const dolfin::Form&)) &dolfin::assemble);
m.def("assemble", (double (*)(const dolfin::Form&)) &dolfin::assemble);
m.def("assemble_system", (void (*)(dolfin::GenericMatrix&, dolfin::GenericVector&,
const dolfin::Form&, const dolfin::Form&,
std::vector>))
&dolfin::assemble_system);
m.def("assemble_system", (void (*)(dolfin::GenericMatrix&, dolfin::GenericVector&,
const dolfin::Form&, const dolfin::Form&,
std::vector>,
const dolfin::GenericVector&))
&dolfin::assemble_system);
m.def("assemble_local", [](const dolfin::Form& form, const dolfin::Cell& cell)
{
Eigen::Matrix m;
dolfin::assemble_local(m, form, cell);
return m;
});
// FEM utils free functions
m.def("create_mesh", dolfin::create_mesh);
m.def("create_mesh", [](const py::object u)
{
auto _u = u.attr("_cpp_object").cast();
return dolfin::create_mesh(*_u);
});
m.def("set_coordinates", &dolfin::set_coordinates);
m.def("set_coordinates", [](dolfin::MeshGeometry& geometry, const py::object u)
{
auto _u = u.attr("_cpp_object").cast();
dolfin::set_coordinates(geometry, *_u);
});
m.def("get_coordinates", &dolfin::get_coordinates);
m.def("get_coordinates", [](py::object u, const dolfin::MeshGeometry& geometry)
{
auto _u = u.attr("_cpp_object").cast();
return dolfin::get_coordinates(*_u, geometry);
});
m.def("vertex_to_dof_map", [](const dolfin::FunctionSpace& V)
{
const auto _v2d = dolfin::vertex_to_dof_map(V);
return py::array_t(_v2d.size(), _v2d.data());
});
m.def("vertex_to_dof_map", [](py::object V)
{
auto _V = V.attr("_cpp_object").cast();
const auto _v2d = dolfin::vertex_to_dof_map(*_V);
return py::array_t(_v2d.size(), _v2d.data());
});
m.def("dof_to_vertex_map", &dolfin::dof_to_vertex_map);
m.def("dof_to_vertex_map", [](py::object V)
{
auto _V = V.attr("_cpp_object").cast();
const auto _d2v = dolfin::dof_to_vertex_map(*_V);
return py::array_t(_d2v.size(), _d2v.data());
});
}
}