// 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()); }); } }