// 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
#include
#include
#include
#include
#include
#include
#include
#include
#include "casters.h"
namespace py = pybind11;
namespace dolfin_wrappers
{
void nls(py::module& m)
{
// dolfin::NewtonSolver 'trampoline' for overloading virtual
// functions from Python
class PyNewtonSolver : public dolfin::NewtonSolver
{
using dolfin::NewtonSolver::NewtonSolver;
// pybdind11 has some issues when passing by reference (due to
// the return value policy), so the below is non-standard. See
// https://github.com/pybind/pybind11/issues/250.
bool converged(const dolfin::GenericVector& r,
const dolfin::NonlinearProblem& nonlinear_problem,
std::size_t iteration)
{
PYBIND11_OVERLOAD_INT(bool, dolfin::NewtonSolver, "converged", &r, &nonlinear_problem, iteration);
return dolfin::NewtonSolver::converged(r, nonlinear_problem, iteration);
}
void solver_setup(std::shared_ptr A,
std::shared_ptr P,
const dolfin::NonlinearProblem& nonlinear_problem,
std::size_t iteration)
{
PYBIND11_OVERLOAD_INT(void, dolfin::NewtonSolver, "solver_setup", A, P,
&nonlinear_problem, iteration);
return dolfin::NewtonSolver::solver_setup(A, P, nonlinear_problem, iteration);
}
void update_solution(dolfin::GenericVector& x, const dolfin::GenericVector& dx,
double relaxation_parameter,
const dolfin::NonlinearProblem& nonlinear_problem,
std::size_t iteration)
{
PYBIND11_OVERLOAD_INT(void, dolfin::NewtonSolver, "update_solution",
&x, &dx, relaxation_parameter, nonlinear_problem,
iteration);
return dolfin::NewtonSolver::update_solution(x, dx, relaxation_parameter,
nonlinear_problem, iteration);
}
};
// Class used to expose protected dolfin::NewtonSolver members
// (see https://github.com/pybind/pybind11/issues/991)
class PyPublicNewtonSolver : public dolfin::NewtonSolver
{
public:
using NewtonSolver::converged;
using NewtonSolver::solver_setup;
using NewtonSolver::update_solution;
};
// dolfin::NewtonSolver
py::class_, PyNewtonSolver,
dolfin::Variable>(m, "NewtonSolver")
.def(py::init<>())
.def(py::init([](const MPICommWrapper comm)
{ return std::unique_ptr(new PyNewtonSolver(comm.get())); }))
.def(py::init([](const MPICommWrapper comm, std::shared_ptr solver,
dolfin::GenericLinearAlgebraFactory& factory)
{ return std::unique_ptr(new PyNewtonSolver(comm.get(), solver, factory)); }))
.def("solve", &dolfin::NewtonSolver::solve)
.def("converged", &PyPublicNewtonSolver::converged)
.def("solver_setup", &PyPublicNewtonSolver::solver_setup)
.def("update_solution", &PyPublicNewtonSolver::update_solution)
.def("linear_solver", &dolfin::NewtonSolver::linear_solver, py::return_value_policy::reference);
#ifdef HAS_PETSC
// dolfin::PETScSNESSolver
py::class_,
dolfin::PETScObject>(m, "PETScSNESSolver")
.def(py::init(), py::arg("nls_type")="default")
.def(py::init([](const MPICommWrapper comm, std::string nls_type="default")
{ return std::unique_ptr(
new dolfin::PETScSNESSolver(comm.get(), nls_type)); }),
py::arg("comm"), py::arg("nls_type") = "default")
.def_readwrite("parameters", &dolfin::PETScSNESSolver::parameters)
.def("snes", &dolfin::PETScSNESSolver::snes)
.def("solve", (std::pair (dolfin::PETScSNESSolver::*)(dolfin::NonlinearProblem&,
dolfin::GenericVector&))
&dolfin::PETScSNESSolver::solve)
.def("set_from_options", &dolfin::PETScSNESSolver::set_from_options);
// dolfin::TAOLinearBoundSolver
py::class_, dolfin::Variable>
(m, "TAOLinearBoundSolver")
.def(py::init([](const MPICommWrapper comm)
{ return std::unique_ptr(new dolfin::TAOLinearBoundSolver(comm.get())); }))
.def(py::init(), py::arg("method")="default",
py::arg("ksp_type")="default", py::arg("pc_type")="default")
.def("solve", (std::size_t (dolfin::TAOLinearBoundSolver::*)
(const dolfin::GenericMatrix&, dolfin::GenericVector&,
const dolfin::GenericVector&, const dolfin::GenericVector&,
const dolfin::GenericVector&))
&dolfin::TAOLinearBoundSolver::solve);
// dolfin::PETScTAOSolver
py::class_, dolfin::PETScObject>(m, "PETScTAOSolver")
.def(py::init<>())
.def(py::init([](const MPICommWrapper comm, std::string tao_type="default",
std::string ksp_type="default", std::string pc_type="default")
{ return std::unique_ptr(
new dolfin::PETScTAOSolver(comm.get(), tao_type, ksp_type, pc_type)); }),
py::arg("comm"), py::arg("tao_type")="default",
py::arg("ksp_type")="default", py::arg("pc_type")="default")
.def_readwrite("parameters", &dolfin::PETScTAOSolver::parameters)
.def("solve", (std::pair (dolfin::PETScTAOSolver::*)(dolfin::OptimisationProblem&, dolfin::GenericVector&))
&dolfin::PETScTAOSolver::solve)
.def("solve", (std::pair (dolfin::PETScTAOSolver::*)(dolfin::OptimisationProblem&, dolfin::GenericVector&,
const dolfin::GenericVector&, const dolfin::GenericVector&))
&dolfin::PETScTAOSolver::solve);
#endif
// dolfin::NonlinearProblem 'trampoline' for overloading from
// Python
class PyNonlinearProblem : public dolfin::NonlinearProblem
{
using dolfin::NonlinearProblem::NonlinearProblem;
// pybdind11 has some issues when passing by reference (due to
// the return value policy), so the below is non-standard. See
// https://github.com/pybind/pybind11/issues/250.
void J(dolfin::GenericMatrix& A, const dolfin::GenericVector& x) override
{
PYBIND11_OVERLOAD_INT(void, dolfin::NonlinearProblem, "J", &A, &x);
py::pybind11_fail("Tried to call pure virtual function dolfin::OptimisationProblem::J");
}
void F(dolfin::GenericVector& b, const dolfin::GenericVector& x) override
{
PYBIND11_OVERLOAD_INT(void, dolfin::NonlinearProblem, "F", &b, &x);
py::pybind11_fail("Tried to call pure virtual function dolfin::OptimisationProblem::F");
}
void form(dolfin::GenericMatrix& A, dolfin::GenericMatrix& P,
dolfin::GenericVector& b, const dolfin::GenericVector& x) override
{
PYBIND11_OVERLOAD_INT(void, dolfin::NonlinearProblem, "form", &A, &P, &b, &x);
return dolfin::NonlinearProblem::form(A, P, b, x);
}
};
// dolfin::NonlinearProblem
py::class_, PyNonlinearProblem>(m, "NonlinearProblem")
.def(py::init<>())
.def("F", &dolfin::NonlinearProblem::F)
.def("J", &dolfin::NonlinearProblem::J)
.def("form", (void (dolfin::NonlinearProblem::*)(dolfin::GenericMatrix&, dolfin::GenericMatrix&,
dolfin::GenericVector&, const dolfin::GenericVector&))
&dolfin::NonlinearProblem::form);
// dolfin::OptimizationProblem 'trampoline' for overloading from
// Python
class PyOptimisationProblem : public dolfin::OptimisationProblem
{
using dolfin::OptimisationProblem::OptimisationProblem;
// pybdind11 has some issues when passing by reference (due to
// the return value policy), so the below is non-standard. See
// https://github.com/pybind/pybind11/issues/250.
double f(const dolfin::GenericVector& x) override
{
PYBIND11_OVERLOAD_INT(double, dolfin::OptimisationProblem, "f", &x);
py::pybind11_fail("Tried to call pure virtual function dolfin::OptimisationProblem::f");
}
void F(dolfin::GenericVector& b, const dolfin::GenericVector& x) override
{
PYBIND11_OVERLOAD_INT(void, dolfin::OptimisationProblem, "F", &b, &x);
py::pybind11_fail("Tried to call pure virtual function dolfin::OptimisationProblem::F");
}
void J(dolfin::GenericMatrix& A, const dolfin::GenericVector& x) override
{
PYBIND11_OVERLOAD_INT(void, dolfin::OptimisationProblem, "J", &A, &x);
py::pybind11_fail("Tried to call pure virtual function dolfin::OptimisationProblem::J");
}
};
// dolfin::OptimizationProblem
py::class_,
PyOptimisationProblem>(m, "OptimisationProblem")
.def(py::init<>())
.def("f", &dolfin::OptimisationProblem::f)
.def("F", &dolfin::OptimisationProblem::F)
.def("J", &dolfin::OptimisationProblem::J);
}
}