Homec4science
Diffusion tamaas (maxwell_viscoelastic-branch) Browse

tamaas/python/wrap/surface.cpp
d6d8134e1bbamaxwell_viscoelastic…

Last Change
Raw File

surface.cpp
View Options

/**
* @file
* @section LICENSE
*
* Copyright (©) 2016-2020 EPFL (École Polytechnique Fédérale de Lausanne),
* Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as published
* by the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program 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 Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*
*/
/* -------------------------------------------------------------------------- */
#include "isopowerlaw.hh"
#include "regularized_powerlaw.hh"
#include "surface_generator_filter.hh"
#include "surface_generator_filter_fft.hh"
#include "surface_generator_random_phase.hh"
#include "wrap.hh"
#include <pybind11/stl.h>
/* -------------------------------------------------------------------------- */
namespace tamaas {
/* -------------------------------------------------------------------------- */
namespace wrap {
using namespace py::literals;
/* -------------------------------------------------------------------------- */
template <UInt dim>
class PyFilter : public Filter<dim> {
public:
using Filter<dim>::Filter;
// Overriding pure virtual functions
void
computeFilter(GridHermitian<Real, dim>& filter_coefficients) const override {
PYBIND11_OVERLOAD_PURE(void, Filter<dim>, computeFilter,
filter_coefficients);
}
};
template <UInt dim>
void wrapFilter(py::module& mod) {
auto name = makeDimensionName("Filter", dim);
py::class_<Filter<dim>, std::shared_ptr<Filter<dim>>, PyFilter<dim>>(
mod, name.c_str())
.def(py::init<>())
.def("computeFilter",
(void (Filter<dim>::*)(GridHermitian<Real, dim>&) const) &
Filter<dim>::computeFilter);
}
/* -------------------------------------------------------------------------- */
template <UInt dim>
void wrapIsopowerlaw(py::module& mod) {
std::string name = makeDimensionName("Isopowerlaw", dim);
py::class_<Isopowerlaw<dim>, Filter<dim>, std::shared_ptr<Isopowerlaw<dim>>>(
mod, name.c_str())
.def(py::init<>())
.def_property("q0", &Isopowerlaw<dim>::getQ0, &Isopowerlaw<dim>::setQ0)
.def_property("q1", &Isopowerlaw<dim>::getQ1, &Isopowerlaw<dim>::setQ1)
.def_property("q2", &Isopowerlaw<dim>::getQ2, &Isopowerlaw<dim>::setQ2)
.def_property("hurst", &Isopowerlaw<dim>::getHurst,
&Isopowerlaw<dim>::setHurst)
.def("rmsHeights", &Isopowerlaw<dim>::rmsHeights)
.def("moments", &Isopowerlaw<dim>::moments)
.def("alpha", &Isopowerlaw<dim>::alpha)
.def("rmsSlopes", &Isopowerlaw<dim>::rmsSlopes)
// legacy wrapper code
.def("getQ0", &Isopowerlaw<dim>::getQ0,
py::return_value_policy::reference)
.def("getQ1", &Isopowerlaw<dim>::getQ1,
py::return_value_policy::reference)
.def("getQ2", &Isopowerlaw<dim>::getQ2,
py::return_value_policy::reference)
.def("setQ0", &Isopowerlaw<dim>::setQ0,
py::return_value_policy::reference)
.def("setQ1", &Isopowerlaw<dim>::setQ1,
py::return_value_policy::reference)
.def("setQ2", &Isopowerlaw<dim>::setQ2,
py::return_value_policy::reference)
.def("setHurst", &Isopowerlaw<dim>::setHurst)
.def("getHurst", &Isopowerlaw<dim>::getHurst,
py::return_value_policy::reference);
name = makeDimensionName("RegularizedPowerlaw", dim);
py::class_<RegularizedPowerlaw<dim>, Filter<dim>,
std::shared_ptr<RegularizedPowerlaw<dim>>>(mod, name.c_str())
.def(py::init<>())
.def_property("q1", &RegularizedPowerlaw<dim>::getQ1,
&RegularizedPowerlaw<dim>::setQ1)
.def_property("q2", &RegularizedPowerlaw<dim>::getQ2,
&RegularizedPowerlaw<dim>::setQ2)
.def_property("hurst", &RegularizedPowerlaw<dim>::getHurst,
&RegularizedPowerlaw<dim>::setHurst);
}
/* -------------------------------------------------------------------------- */
template <UInt dim>
void wrapSurfaceGenerators(py::module& mod) {
std::string generator_name = makeDimensionName("SurfaceGenerator", dim);
py::class_<SurfaceGenerator<dim>>(mod, generator_name.c_str())
.def("buildSurface", &SurfaceGenerator<dim>::buildSurface,
py::return_value_policy::reference_internal)
.def("setSizes",
py::overload_cast<const std::array<UInt, dim>&>(
&SurfaceGenerator<dim>::setSizes),
"surface_sizes"_a)
.def_property("random_seed", &SurfaceGenerator<dim>::getRandomSeed,
&SurfaceGenerator<dim>::setRandomSeed);
std::string filter_name = makeDimensionName("SurfaceGeneratorFilter", dim);
py::class_<SurfaceGeneratorFilter<dim>, SurfaceGenerator<dim>>(
mod, filter_name.c_str())
.def(py::init<>())
.def("setFilter", &SurfaceGeneratorFilter<dim>::setFilter,
"Set PSD filter", "filter"_a)
.def("setSpectrum", &SurfaceGeneratorFilter<dim>::setSpectrum,
"Set PSD spectrum", "filter"_a)
// legacy wrapper code
.def("setRandomSeed", &SurfaceGeneratorFilter<dim>::setRandomSeed,
"[[Deprecated: use property]]");
std::string random_name =
makeDimensionName("SurfaceGeneratorRandomPhase", dim);
py::class_<SurfaceGeneratorRandomPhase<dim>, SurfaceGenerator<dim>>(
mod, random_name.c_str())
.def(py::init<>())
.def("setFilter", &SurfaceGeneratorRandomPhase<dim>::setFilter,
"Set PSD filter", "filter"_a)
.def("setSpectrum", &SurfaceGeneratorRandomPhase<dim>::setSpectrum,
"Set PSD Spectrum", "spectrum"_a);
}
/* -------------------------------------------------------------------------- */
// Legacy wrap
void wrapSurfaceGeneratorFilterFFT(py::module& mod) {
py::class_<SurfaceGeneratorFilterFFT>(mod, "SurfaceGeneratorFilterFFT")
.def(py::init<>())
.def("getQ0",
[](SurfaceGeneratorFilterFFT& f) {
return smart_pointer<UInt>(&f.getQ0());
})
.def("getQ1",
[](SurfaceGeneratorFilterFFT& f) {
return smart_pointer<UInt>(&f.getQ1());
})
.def("getQ2",
[](SurfaceGeneratorFilterFFT& f) {
return smart_pointer<UInt>(&f.getQ2());
})
.def("getHurst",
[](SurfaceGeneratorFilterFFT& f) {
return smart_pointer<Real>(&f.getHurst());
})
.def("analyticalRMS", &SurfaceGeneratorFilterFFT::analyticalRMS)
.def("buildSurface", &SurfaceGeneratorFilterFFT::buildSurface,
py::return_value_policy::reference_internal)
.def("getGridSize",
[](SurfaceGeneratorFilterFFT& f) {
return smart_pointer<UInt>(&f.getGridSize());
})
.def("getRandomSeed",
[](SurfaceGeneratorFilterFFT& f) {
return smart_pointer<long>(&f.getRandomSeed());
})
.def("getRMS",
[](SurfaceGeneratorFilterFFT& f) {
return smart_pointer<Real>(&f.getRMS());
})
.def("Init", &SurfaceGeneratorFilterFFT::Init);
}
/* -------------------------------------------------------------------------- */
void wrapSurface(py::module& mod) {
wrapFilter<1>(mod);
wrapFilter<2>(mod);
wrapIsopowerlaw<1>(mod);
wrapIsopowerlaw<2>(mod);
wrapSurfaceGenerators<1>(mod);
wrapSurfaceGenerators<2>(mod);
// legacy wrap
#if defined(TAMAAS_LEGACY_BEM)
wrapSurfaceGeneratorFilterFFT(mod);
#endif
}
} // namespace wrap
/* -------------------------------------------------------------------------- */
} // namespace tamaas
c4science · Help