diff --git a/python/wrap/model.cpp b/python/wrap/model.cpp index a7269f4..33c3334 100644 --- a/python/wrap/model.cpp +++ b/python/wrap/model.cpp @@ -1,147 +1,157 @@ /** * @file * * @author Lucas Frérot * * @section LICENSE * * Copyright (©) 2017 EPFL (Ecole Polytechnique Fédérale de * Lausanne) Laboratory (LSMS - Laboratoire de Simulation en Mécanique des * Solides) * * Tamaas 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. * * Tamaas 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 Tamaas. If not, see . * */ /* -------------------------------------------------------------------------- */ #include "wrap.hh" #include "model.hh" #include "model_factory.hh" #include "functional.hh" #include "adhesion_functional.hh" +#include "residual.hh" #include /* -------------------------------------------------------------------------- */ __BEGIN_TAMAAS__ namespace functional { namespace wrap { /// Class for extension of Functional in python class PyFunctional : public Functional { public: using Functional::Functional; // Overriding pure virtual functions Real computeF(GridBase& variable, GridBase& dual) const override { PYBIND11_OVERLOAD_PURE(Real, Functional, computeF, variable, dual); } void computeGradF(GridBase& variable, GridBase& gradient) const override { PYBIND11_OVERLOAD_PURE(void, Functional, computeGradF, variable, gradient); } }; } } namespace wrap { using namespace py::literals; /// Wrap functional classes void wrapFunctionals(py::module& mod) { py::class_ func( mod, "Functional"); func.def(py::init<>()) .def("computeF", &functional::Functional::computeF) .def("computeGradF", &functional::Functional::computeGradF); py::class_ adh(mod, "AdhesionFunctional", func); adh.def_property("parameters", &functional::AdhesionFunctional::getParameters, &functional::AdhesionFunctional::setParameters) // legacy wrapper code .def("setParameters", &functional::AdhesionFunctional::setParameters); py::class_( mod, "ExponentialAdhesionFunctional", adh) .def(py::init&>(), "surface"_a); py::class_( mod, "MaugisAdhesionFunctional", adh) .def(py::init&>(), "surface"_a); py::class_( mod, "SquaredExponentialAdhesionFunctional", adh) .def(py::init&>(), "surface"_a); } /// Wrap BEEngine classes void wrapBEEngine(py::module& mod) { py::class_(mod, "BEEngine") .def("solveNeumann", &BEEngine::solveNeumann) .def("solveDirichlet", &BEEngine::solveDirichlet) .def("getModel", &BEEngine::getModel, py::return_value_policy::reference); } /// Wrap Models void wrapModelClass(py::module& mod) { py::enum_(mod, "model_type") .value("basic_1d", model_type::basic_1d) .value("basic_2d", model_type::basic_2d) .value("surface_1d", model_type::surface_1d) .value("surface_2d", model_type::surface_2d) .value("volume_1d", model_type::volume_1d) .value("volume_2d", model_type::volume_2d); py::class_(mod, "Model") .def("setElasticity", &Model::setElasticity, "E"_a, "nu"_a) .def_property("E", &Model::getYoungModulus, &Model::setYoungModulus) .def_property("nu", &Model::getPoissonRatio, &Model::setPoissonRatio) .def("getHertzModulus", &Model::getHertzModulus) .def("getYoungModulus", &Model::getYoungModulus) .def("getShearModulus", &Model::getShearModulus) .def("getPoissonRatio", &Model::getPoissonRatio) .def("getTraction", (GridBase & (Model::*)()) & Model::getTraction) .def("getDisplacement", (GridBase & (Model::*)()) & Model::getDisplacement) .def("getSystemSize", &Model::getSystemSize) .def("getDiscretization", &Model::getDiscretization) .def("solveNeumann", &Model::solveNeumann) .def("solveDirichlet", &Model::solveDirichlet) .def("getBEEngine", &Model::getBEEngine, py::return_value_policy::reference) .def("__repr__", [](const Model& m) { std::stringstream ss; ss << m; return ss.str(); }); } -/// Wrap factor for models +/// Wrap factory for models void wrapModelFactory(py::module& mod) { py::class_(mod, "ModelFactory") .def_static("createModel", &ModelFactory::createModel, "model_type"_a, "system_size"_a, "discretization"_a); } +/// Wrap residual class +void wrapResidual(py::module& mod) { + py::class_(mod, "Residual") + .def("getVector", &Residual::getVector) + .def("getPlasticStrain", &Residual::getPlasticStrain) + .def("getStress", &Residual::getStress); +} + void wrapModel(py::module& mod) { wrapBEEngine(mod); wrapModelClass(mod); wrapModelFactory(mod); wrapFunctionals(mod); + wrapResidual(mod); } } // namespace wrap __END_TAMAAS__ diff --git a/src/model/elasto_plastic/residual.hh b/src/model/elasto_plastic/residual.hh index 2e80b54..68666f2 100644 --- a/src/model/elasto_plastic/residual.hh +++ b/src/model/elasto_plastic/residual.hh @@ -1,108 +1,108 @@ /** * @file * * @author Lucas Frérot * * @section LICENSE * * Copyright (©) 2017 EPFL (Ecole Polytechnique Fédérale de * Lausanne) Laboratory (LSMS - Laboratoire de Simulation en Mécanique des * Solides) * * Tamaas 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. * * Tamaas 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 Tamaas. If not, see . * */ /* -------------------------------------------------------------------------- */ #ifndef RESIDUAL_HH #define RESIDUAL_HH /* -------------------------------------------------------------------------- */ #include "isotropic_hardening.hh" #include "model_type.hh" #include "mindlin.hh" #include "boussinesq.hh" /* -------------------------------------------------------------------------- */ namespace tamaas { /* -------------------------------------------------------------------------- */ /** * @brief Residual manager */ class Residual { public: /// Constructor Residual(Model* model) : model(model) {} /// Destructor virtual ~Residual() = default; // Pure virtual methods public: /// Compute the residual vector for a given strain increment virtual void computeResidual(GridBase& strain_increment) = 0; /// Compute the stresses for a given strain increment virtual void computeStress(GridBase& strain_increment) = 0; /// Update the plastic state virtual void updateState(GridBase& converged_strain_increment) = 0; /// Get residual vector virtual const GridBase& getVector() const = 0; /// Get plastic strain virtual const GridBase& getPlasticStrain() const = 0; /// Get stresses virtual const GridBase& getStress() const = 0; protected: Model* model; }; /** * @brief Templated residual manager */ template class ResidualTemplate : public Residual { using trait = model_type_traits; static constexpr UInt dim = trait::dimension; public: ResidualTemplate(Model * model, Real sigma_0, Real h); // Implementation public: /// Compute the residual vector for a given strain increment void computeResidual(GridBase& strain_increment) override; /// Compute the stresses for a given strain increment void computeStress(GridBase& strain_increment) override; /// Update the plastic state void updateState(GridBase& converged_strain_increment) override; // Accessors public: /// Get residual vector const GridBase& getVector() const override { return residual; } /// Get plastic strain const GridBase& getPlasticStrain() const override { return hardening.getPlasticStrain(); } /// Get stresses const GridBase& getStress() const override { return stress; } protected: IsotropicHardening hardening; Mindlin hypersingular_operator; - Boussinesq boundary_operator; + Boussinesq boundary_operator; Grid strain, stress, residual, tmp; }; /* -------------------------------------------------------------------------- */ } // namespace tamaas #endif // RESIDUAL_HH