// 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 "casters.h"
#include "MPICommWrapper.h"
namespace py = pybind11;
namespace dolfin_wrappers
{
// Interface for dolfin/common
void common(py::module& m)
{
// dolfin::Variable
py::class_>
(m, "Variable", "Variable base class")
.def("id", &dolfin::Variable::id)
.def("name", &dolfin::Variable::name)
.def("label", &dolfin::Variable::label)
.def("rename", &dolfin::Variable::rename)
.def_readwrite("parameters", &dolfin::Variable::parameters);
// From dolfin/common/defines.h
m.def("has_debug", &dolfin::has_debug);
m.def("has_hdf5", &dolfin::has_hdf5);
m.def("has_hdf5_parallel", &dolfin::has_hdf5_parallel);
m.def("has_mpi", &dolfin::has_mpi);
m.def("has_mpi4py", []()
{
#ifdef HAS_PYBIND11_MPI4PY
return true;
#else
return false;
#endif
}, "Return `True` if DOLFIN is configured with mpi4py");
m.def("has_parmetis", &dolfin::has_parmetis);
m.def("has_scotch", &dolfin::has_scotch);
m.def("has_petsc", &dolfin::has_petsc,
"Return `True` if DOLFIN is configured with PETSc");
m.def("has_slepc", &dolfin::has_slepc,
"Return `True` if DOLFIN is configured with SLEPc");
m.def("has_sundials", &dolfin::has_sundials,
"Return `True` if DOLFIN is configured with SUNDIALS");
m.def("has_petsc4py", []()
{
#ifdef HAS_PYBIND11_PETSC4PY
return true;
#else
return false;
#endif
}, "Return `True` if DOLFIN is configured with petsc4py");
m.def("has_slepc4py", []()
{
#ifdef HAS_PYBIND11_SLEPC4PY
return true;
#else
return false;
#endif
}, "Return `True` if DOLFIN is configured with slepc4py");
m.def("git_commit_hash", &dolfin::git_commit_hash,
"Returns git hash for this build.");
m.def("sizeof_la_index", &dolfin::sizeof_la_index);
m.attr("DOLFIN_EPS") = DOLFIN_EPS;
m.attr("DOLFIN_EPS_LARGE") = DOLFIN_EPS_LARGE;
m.attr("DOLFIN_PI") = DOLFIN_PI;
// dolfin::Timer
py::class_>
(m, "Timer", "Timer class")
.def(py::init<>())
.def(py::init())
.def("start", &dolfin::Timer::start, "Start timer")
.def("stop", &dolfin::Timer::stop, "Stop timer")
.def("resume", &dolfin::Timer::resume)
.def("elapsed", &dolfin::Timer::elapsed);
// dolfin::Timer enums
py::enum_(m, "TimingClear")
.value("clear", dolfin::TimingClear::clear)
.value("keep", dolfin::TimingClear::keep);
py::enum_(m, "TimingType")
.value("wall", dolfin::TimingType::wall)
.value("system", dolfin::TimingType::system)
.value("user", dolfin::TimingType::user);
// dolfin/common free functions
m.def("timing", &dolfin::timing);
m.def("timings", [](dolfin::TimingClear clear, std::vector type)
{
std::set _type(type.begin(), type.end());
return dolfin::timings(clear, _type);
});
m.def("list_timings", [](dolfin::TimingClear clear, std::vector type)
{
std::set _type(type.begin(), type.end());
dolfin::list_timings(clear, _type);
});
m.def("dump_timings_to_xml", &dolfin::dump_timings_to_xml);
// dolfin::SubSystemsManager
py::class_>
(m, "SubSystemsManager")
.def_static("init_petsc", (void (*)()) &dolfin::SubSystemsManager::init_petsc)
.def_static("init_petsc", [](std::vector args)
{
std::vector argv(args.size());
for (std::size_t i = 0; i < args.size(); ++i)
argv[i] = const_cast(args[i].data());
dolfin::SubSystemsManager::init_petsc(args.size(), argv.data());
})
.def_static("finalize", &dolfin::SubSystemsManager::finalize)
.def_static("responsible_mpi", &dolfin::SubSystemsManager::responsible_mpi)
.def_static("responsible_petsc", &dolfin::SubSystemsManager::responsible_petsc)
.def_static("mpi_initialized", &dolfin::SubSystemsManager::mpi_initialized)
.def_static("mpi_finalized", &dolfin::SubSystemsManager::mpi_finalized);
}
// Interface for MPI
void mpi(py::module& m)
{
#ifndef HAS_PYBIND11_MPI4PY
// Expose the MPICommWrapper directly since we cannot cast it to
// mpi4py
py::class_(m, "MPICommWrapper",
"DOLFIN is compiled without support for mpi4py. This object can be "
"passed into DOLFIN as an MPI communicator, but is not an mpi4py comm.")
.def("underlying_comm", [](MPICommWrapper self)
{ return (std::uintptr_t) self.get(); },
"Return the underlying MPI_Comm cast to std::uintptr_t. "
"The return value may or may not make sense depending on the MPI implementation.");
#endif
// dolfin::MPI
py::class_(m, "MPI", "MPI utilities")
.def_property_readonly_static("comm_world", [](py::object)
{ return MPICommWrapper(MPI_COMM_WORLD); })
.def_property_readonly_static("comm_self", [](py::object)
{ return MPICommWrapper(MPI_COMM_SELF); })
.def_property_readonly_static("comm_null", [](py::object)
{ return MPICommWrapper(MPI_COMM_NULL); })
.def_static("init", (void (*)()) &dolfin::SubSystemsManager::init_mpi,
"Initialise MPI")
.def_static("init",
[](std::vector args, int required_thread_level)->int
{
std::vector argv(args.size());
for (std::size_t i = 0; i < args.size(); ++i)
argv[i] = const_cast(args[i].data());
return dolfin::SubSystemsManager::
init_mpi(args.size(), argv.data(), required_thread_level);
},
"Initialise MPI with command-line args and required level "
"of thread support. Return provided thread level.")
.def_static("responsible", &dolfin::SubSystemsManager::responsible_mpi,
"Return true if DOLFIN initialised MPI (and is therefore "
"responsible for finalization)")
.def_static("initialized", &dolfin::SubSystemsManager::mpi_initialized,
"Check if MPI has been initialised")
.def_static("finalized", &dolfin::SubSystemsManager::mpi_finalized,
"Check if MPI has been finalized")
.def_static("barrier", [](const MPICommWrapper comm)
{ return dolfin::MPI::barrier(comm.get()); })
.def_static("rank", [](const MPICommWrapper comm)
{ return dolfin::MPI::rank(comm.get()); })
.def_static("size", [](const MPICommWrapper comm)
{ return dolfin::MPI::size(comm.get()); })
.def_static("local_range", [](MPICommWrapper comm, std::int64_t N)
{ return dolfin::MPI::local_range(comm.get(), N); })
// templated for double
.def_static("max", [](const MPICommWrapper comm, double value)
{ return dolfin::MPI::max(comm.get(), value); })
.def_static("min", [](const MPICommWrapper comm, double value)
{ return dolfin::MPI::min(comm.get(), value); })
.def_static("sum", [](const MPICommWrapper comm, double value)
{ return dolfin::MPI::sum(comm.get(), value); })
// templated for dolfin::Table
.def_static("max", [](const MPICommWrapper comm, dolfin::Table value)
{ return dolfin::MPI::max(comm.get(), value); })
.def_static("min", [](const MPICommWrapper comm, dolfin::Table value)
{ return dolfin::MPI::min(comm.get(), value); })
.def_static("sum", [](const MPICommWrapper comm, dolfin::Table value)
{ return dolfin::MPI::sum(comm.get(), value); })
.def_static("avg", [](const MPICommWrapper comm, dolfin::Table value)
{ return dolfin::MPI::avg(comm.get(), value); });
}
}