// 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 "casters.h"
namespace py = pybind11;
namespace dolfin_wrappers
{
void parameter(py::module& m)
{
// dolfin::Parameters
py::class_>
(m, "Parameters")
.def(py::init<>())
.def(py::init())
.def(py::init())
.def(py::init([](std::string name, py::kwargs kwargs)
{
dolfin::Parameters p(name);
if (kwargs)
{
for (auto item : kwargs)
{
std::string key = std::string(py::str(item.first));
auto value = item.second;
if (py::isinstance(value))
p.add(key, value.cast());
else if (py::isinstance(value))
p.add(key, value.cast());
else if (py::isinstance(value))
p.add(key, value.cast());
else if (py::isinstance(value))
p.add(value.cast());
else if (py::isinstance(value))
{
auto t = value.cast();
if (t.size() == 2)
p.add(key, t[0].cast(), t[1].cast>());
if (t.size() == 3)
{
if (py::isinstance(t[0]))
p.add(key, t[0].cast(), t[1].cast(), t[2].cast());
else if (py::isinstance(t[0]))
p.add(key, t[0].cast(), t[1].cast(), t[2].cast());
else
throw std::runtime_error("Unknown parameter type with range - expecting int or float");
}
}
else
throw std::runtime_error("Unknown parameter type.");
}
}
return p;
}
))
// Use boost::variant to simplify
.def("add", (void (dolfin::Parameters::*)(std::string, std::string)) &dolfin::Parameters::add)
.def("add", (void (dolfin::Parameters::*)(std::string, std::string, std::set)) &dolfin::Parameters::add)
.def("add", (void (dolfin::Parameters::*)(std::string, bool)) &dolfin::Parameters::add)
.def("add", (void (dolfin::Parameters::*)(std::string, int, int, int)) &dolfin::Parameters::add)
.def("add", (void (dolfin::Parameters::*)(std::string, int)) &dolfin::Parameters::add)
.def("add", (void (dolfin::Parameters::*)(std::string, double)) &dolfin::Parameters::add)
.def("add", (void (dolfin::Parameters::*)(std::string, double, double, double)) &dolfin::Parameters::add)
.def("add", (void (dolfin::Parameters::*)(const dolfin::Parameters&)) &dolfin::Parameters::add)
// Support iterators
.def("__len__", &dolfin::Parameters::size)
.def("__iter__", [](const dolfin::Parameters& p) { return py::make_key_iterator(p.begin(), p.end()); },
py::keep_alive<0, 1>())
.def("items", [](const dolfin::Parameters& p) { return py::make_iterator(p.begin(), p.end()); },
py::keep_alive<0, 1>())
.def("keys", [](const dolfin::Parameters& p)
{
std::vector keys;
for (auto &q : p)
keys.push_back(q.first);
return keys;
})
// These set_range function should be remove - they're just duplication
.def("set_range", [](dolfin::Parameters& self, std::string name, double min, double max)
{ self[name].set_range(min, max);} )
.def("set_range", [](dolfin::Parameters& self, std::string name, int min, int max)
{ self[name].set_range(min, max);} )
.def("set_range", [](dolfin::Parameters& self, std::string name, std::set range)
{ self[name].set_range(range);} )
.def("get_range", [](dolfin::Parameters& self, std::string key)
{
const auto& p = self.find_parameter(key);
std::set range;
p->get_range(range);
return range;
})
.def("name", &dolfin::Parameters::name)
.def("rename", &dolfin::Parameters::rename)
.def("str", &dolfin::Parameters::str)
.def("has_parameter", &dolfin::Parameters::has_parameter)
.def("has_parameter_set", &dolfin::Parameters::has_parameter_set)
.def("_update", &dolfin::Parameters::update)
.def("_get_parameter", (dolfin::Parameter& (dolfin::Parameters::*)(std::string))
&dolfin::Parameters::operator[], py::return_value_policy::reference)
.def("_get_parameter_set", (dolfin::Parameters& (dolfin::Parameters::*)(std::string))
&dolfin::Parameters::operator(), py::return_value_policy::reference)
/*
// With boost::variant, need to figure out how to set the
// return policy per type in variant
.def("__getitem__", [](dolfin::Parameters& self, std::string key)
{
mapbox::util::variant v;
auto param = self.find_parameter(key);
if (auto param = self.find_parameter(key))
{
// FIXME: This will be simple once boost::variant is working
//return param->value();
auto _v = param->value();
if (_v.which() == 1)
v = boost::get(_v);
else if (_v.which() == 2)
v = boost::get(_v);
else if (_v.which() == 3)
v = boost::get(_v);
else if (_v.which() == 4)
v = boost::get(_v);
else
throw std::runtime_error("Cannot get parameter value");
return v;
}
else if (auto param = self.find_parameter_set(key))
{
//v = &(*param);
v = &self("key");
return v;
}
else
throw std::runtime_error("Invalid parameter key: " + key);
}, py::return_value_policy::automatic_reference)
*/
// FIXME: Implement checks and error handling below
// FIXME: Can these functions be consolidated. Maybe boost::variant can help?
.def("__setitem__", [](dolfin::Parameters& self, std::string key, py::none value)
{
auto param = self.find_parameter(key);
if (!param)
throw std::runtime_error("Parameter " + key + " not found in Parameters object");
param->reset();
}, "Reset Parameter (mark as unset) by setting to None.")
.def("__setitem__", [](dolfin::Parameters& self, std::string key, bool value)
{
auto param = self.find_parameter(key);
if (!param)
throw std::runtime_error("Parameter " + key + " not found in Parameters object");
*param = value;
}, py::arg(), py::arg().noconvert())
.def("__setitem__", [](dolfin::Parameters& self, std::string key, std::string value)
{
auto param = self.find_parameter(key);
if (!param)
throw std::runtime_error("Parameter " + key + " not found in Parameters object");
*param = value;
})
.def("__setitem__", [](dolfin::Parameters& self, std::string key, int value)
{
auto param = self.find_parameter(key);
if (!param)
throw std::runtime_error("Parameter " + key + " not found in Parameters object");
*param = value;
})
.def("__setitem__", [](dolfin::Parameters& self, std::string key, double value)
{
auto param = self.find_parameter(key);
if (!param)
throw std::runtime_error("Parameter " + key + " not found in Parameters object");
*param = value;
})
.def("__setitem__", [](dolfin::Parameters& self, std::string key, const dolfin::Parameters& other)
{
auto param = self.find_parameter_set(key);
if (!param)
throw std::runtime_error("Parameter " + key + " not found in Parameters object");
*param = other;
})
.def("__getitem__", [](dolfin::Parameters& self, std::string key)
{
return self[key];
})
.def("parse", [](dolfin::Parameters& self, py::list argv)
{
if (argv.size() == 0)
argv = py::module::import("sys").attr("argv").cast();
const int argc = argv.size();
std::vector a;
for (auto q : argv)
a.push_back(q.cast());
char* char_args[argc];
for (int j=0; j>(m, "Parameter")
.def("value", [](const dolfin::Parameter& self)
{
py::object value;
if (self.is_set())
value = py::cast(self.value());
else
value = py::none();
return value;
})
.def("set_range", (void (dolfin::Parameter::*)(double, double)) &dolfin::Parameter::set_range)
.def("set_range", (void (dolfin::Parameter::*)(int, int)) &dolfin::Parameter::set_range)
.def("set_range", (void (dolfin::Parameter::*)(std::set)) &dolfin::Parameter::set_range)
.def("__str__", &dolfin::Parameter::value_str);
// dolfin::GlobalParameters
py::class_,
dolfin::Parameters> (m, "GlobalParameters");
// The global parameters (return a reference because there should
// be only one instance)
m.attr("parameters") = &dolfin::parameters;
}
}