model.cpp
No OneTemporary
Actions

Subscribers

None

File Metadata

Created: Tue, Apr 30, 19:59

model.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 "model.hh"
	#include "adhesion_functional.hh"
	#include "functional.hh"
	#include "integral_operator.hh"
	#include "model_dumper.hh"
	#include "model_extensions.hh"
	#include "model_factory.hh"
	#include "numpy.hh"
	#include "residual.hh"
	#include "wrap.hh"
	#include <pybind11/stl.h>
	/* -------------------------------------------------------------------------- */

	namespace tamaas {

	namespace wrap {

	using namespace py::literals;

	struct model_operator_accessor {
	Model& m;

	decltype(auto) get(std::string name) {
	return m.getIntegralOperator(std::move(name));
	}
	};

	/// Wrap functional classes
	void wrapFunctionals(py::module& mod) {
	py::class_<functional::Functional, std::shared_ptr<functional::Functional>,
	functional::wrap::PyFunctional>
	func(mod, "Functional");
	func.def(py::init<>())
	.def("computeF", &functional::Functional::computeF)
	.def("computeGradF", &functional::Functional::computeGradF);

	py::class_<functional::AdhesionFunctional> adh(mod, "AdhesionFunctional",
	func);
	adh.def_property("parameters", &functional::AdhesionFunctional::getParameters,
	&functional::AdhesionFunctional::setParameters)
	// TODO [legacy] remove wrapper code
	.def("setParameters", &functional::AdhesionFunctional::setParameters);

	py::class_<functional::ExponentialAdhesionFunctional>(
	mod, "ExponentialAdhesionFunctional", adh)
	.def(py::init<const GridBase<Real>&>(), "surface"_a);
	py::class_<functional::MaugisAdhesionFunctional>(
	mod, "MaugisAdhesionFunctional", adh)
	.def(py::init<const GridBase<Real>&>(), "surface"_a);
	py::class_<functional::SquaredExponentialAdhesionFunctional>(
	mod, "SquaredExponentialAdhesionFunctional", adh)
	.def(py::init<const GridBase<Real>&>(), "surface"_a);
	}

	template <typename T>
	std::unique_ptr<GridBase<T>> instanciateFromNumpy(numpy<T>& num) {
	std::unique_ptr<GridBase<T>> result = nullptr;

	switch (num.ndim()) {
	case 2:
	result = std::make_unique<GridNumpy<Grid<T, 1>>>(num);
	return result;
	case 3:
	result = std::make_unique<GridNumpy<Grid<T, 2>>>(num);
	return result;
	case 4:
	result = std::make_unique<GridNumpy<Grid<T, 3>>>(num);
	return result;
	default:
	TAMAAS_EXCEPTION("instanciateFromNumpy expects the last dimension of numpy "
	"array to be the number of components");
	}
	}

	/// Wrap IntegralOperator
	void wrapIntegralOperator(py::module& mod) {
	py::class_<IntegralOperator>(mod, "IntegralOperator")
	// TODO [legacy] remove
	.def("apply",
	[](IntegralOperator& op, numpy<Real> input, numpy<Real> output) {
	auto in = instanciateFromNumpy(input);
	auto out = instanciateFromNumpy(output);

	op.apply(in, out);
	})
	.def("getModel", &IntegralOperator::getModel,
	py::return_value_policy::reference)
	.def("getKind", &IntegralOperator::getKind)
	.def("getType", &IntegralOperator::getType)

	.def("__call__",
	[](IntegralOperator& op, numpy<Real> input, numpy<Real> output) {
	auto in = instanciateFromNumpy(input);
	auto out = instanciateFromNumpy(output);

	op.apply(in, out);
	})
	.def("updateFromModel", &IntegralOperator::updateFromModel)

	.def_property_readonly("model", &IntegralOperator::getModel)
	.def_property_readonly("type", &IntegralOperator::getType);

	py::enum_<integration_method>(mod, "integration_method")
	.value("linear", integration_method::linear)
	.value("cutoff", integration_method::cutoff);
	}

	/// Wrap BEEngine classes
	void wrapBEEngine(py::module& mod) {
	py::class_<BEEngine>(mod, "BEEngine")
	.def("solveNeumann", &BEEngine::solveNeumann)
	.def("solveDirichlet", &BEEngine::solveDirichlet)
	.def("registerNeumann", &BEEngine::registerNeumann)
	.def("registerDirichlet", &BEEngine::registerDirichlet)
	// TODO [legacy] remove
	.def("getModel", &BEEngine::getModel, py::return_value_policy::reference)

	.def_property_readonly("model", &BEEngine::getModel);
	}

	template <model_type type>
	void wrapModelTypeTrait(py::module& mod) {
	using trait = model_type_traits<type>;
	py::class_<trait>(mod, trait::repr)
	.def_property_readonly_static("dimension",
	[](py::object) { return trait::dimension; })
	.def_property_readonly_static(
	"components", [](py::object) { return trait::components; })
	.def_property_readonly_static(
	"boundary_dimension",
	[](py::object) { return trait::boundary_dimension; })
	.def_property_readonly_static("voigt",
	[](py::object) { return trait::voigt; })
	.def_property_readonly_static("indices",
	[](py::object) { return trait::indices; });
	}

	/// Wrap Models
	void wrapModelClass(py::module& mod) {
	py::enum_<model_type>(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);

	auto trait_mod = mod.def_submodule("_type_traits");
	wrapModelTypeTrait<model_type::basic_1d>(trait_mod);
	wrapModelTypeTrait<model_type::surface_1d>(trait_mod);
	wrapModelTypeTrait<model_type::volume_1d>(trait_mod);
	wrapModelTypeTrait<model_type::basic_2d>(trait_mod);
	wrapModelTypeTrait<model_type::surface_2d>(trait_mod);
	wrapModelTypeTrait<model_type::volume_2d>(trait_mod);

	py::class_<model_operator_accessor>(mod, "_model_operator_acessor")
	.def(py::init<Model&>())
	.def("__getitem__",
	[](model_operator_accessor& acc, std::string name) {
	try {
	return acc.get(name);
	} catch (std::out_of_range&) {
	throw py::key_error(name);
	}
	},
	py::return_value_policy::reference_internal)
	.def("__contains__",
	[](model_operator_accessor& acc, std::string key) {
	const auto ops = acc.m.getIntegralOperators();
	return std::find(ops.begin(), ops.end(), key) != ops.end();
	})
	.def("__iter__",
	[](const model_operator_accessor& acc) {
	const auto& ops = acc.m.getIntegralOperatorsMap();
	return py::make_key_iterator(ops.cbegin(), ops.cend());
	},
	py::keep_alive<0, 1>());

	py::class_<Model>(mod, "Model")
	.def_property_readonly("type", &Model::getType)
	.def_property("E", &Model::getYoungModulus, &Model::setYoungModulus,
	"Young's modulus")
	.def_property("nu", &Model::getPoissonRatio, &Model::setPoissonRatio,
	"Poisson's ratio")
	.def_property_readonly("mu", &Model::getShearModulus, "Shear modulus")
	.def_property_readonly("E_star", &Model::getHertzModulus,
	"Contact (Hertz) modulus")

	// TODO [legacy] remove
	.def("setElasticity", &Model::setElasticity, "E"_a, "nu"_a)
	.def("getHertzModulus", &Model::getHertzModulus)
	.def("getYoungModulus", &Model::getYoungModulus)
	.def("getShearModulus", &Model::getShearModulus)
	.def("getPoissonRatio", &Model::getPoissonRatio)
	.def("getTraction", (GridBase<Real> & (Model::*)()) & Model::getTraction,
	py::return_value_policy::reference_internal)
	.def("getDisplacement",
	(GridBase<Real> & (Model::*)()) & Model::getDisplacement,
	py::return_value_policy::reference_internal)
	.def("getSystemSize", &Model::getSystemSize)
	.def("getDiscretization", &Model::getDiscretization)
	.def("getBoundarySystemSize", &Model::getBoundarySystemSize)
	.def("getBoundaryDiscretization", &Model::getBoundaryDiscretization)

	.def("solveNeumann", &Model::solveNeumann)
	.def("solveDirichlet", &Model::solveDirichlet)
	.def("dump", &Model::dump)
	.def("addDumper", &Model::addDumper, "dumper"_a, py::keep_alive<1, 2>())
	.def("setDumper",
	[](Model&, const ModelDumper&) {
	TAMAAS_EXCEPTION("setDumper() is not a member of Model; use "
	"addDumper() instead");
	})
	.def("getBEEngine", &Model::getBEEngine,
	py::return_value_policy::reference_internal)
	.def("getIntegralOperator", &Model::getIntegralOperator,
	"operator_name"_a, py::return_value_policy::reference_internal)
	.def("registerField",
	[](Model& m, std::string name, numpy<Real> field) {
	auto f = instanciateFromNumpy(field);
	m.registerField(name, std::move(f));
	},
	"field_name"_a, "field"_a, py::keep_alive<1, 3>())
	.def("getField",
	(GridBase<Real> & (Model::*)(const std::string&)) & Model::getField,
	"field_name"_a, py::return_value_policy::reference_internal)

	.def("getFields", &Model::getFields, "Return fields list")
	.def("applyElasticity",
	[](Model& model, numpy<Real> stress, numpy<Real> strain) {
	auto out = instanciateFromNumpy(stress);
	auto in = instanciateFromNumpy(strain);

	model.applyElasticity(out, in);
	},
	"Apply Hooke's law")

	// Python magic functions
	.def("__repr__",
	[](const Model& m) {
	std::stringstream ss;
	ss << m;
	return ss.str();
	})
	.def("__getitem__",
	[](const Model& m, std::string key) -> const GridBase<Real>& {
	try {
	return m[key];
	} catch (std::out_of_range&) {
	throw py::key_error(key);
	}
	},
	py::return_value_policy::reference_internal, "Get field")
	.def("__setitem__",
	[](Model& m, std::string name, numpy<Real> field) {
	auto f = instanciateFromNumpy(field);
	m.registerField(name, std::move(f));
	},
	py::keep_alive<1, 3>(), "Register new field")
	.def("__contains__",
	[](const Model& m, std::string key) {
	const auto fields = m.getFields();
	return std::find(fields.begin(), fields.end(), std::move(key)) !=
	fields.end();
	},
	py::keep_alive<0, 1>(), "Test field existence")
	.def("__iter__",
	[](const Model& m) {
	const auto& fields = m.getFieldsMap();
	return py::make_key_iterator(fields.cbegin(), fields.cend());
	},
	py::keep_alive<0, 1>(), "Iterator on fields")
	.def_property_readonly(
	"operators", [](Model& m) { return model_operator_accessor{m}; },
	"Returns a dict-like object allowing access to the model's integral "
	"operators")
	// More python-like access to model properties
	.def_property_readonly("shape", &Model::getDiscretization,
	"Discretization (local in MPI environment)")
	.def_property_readonly("global_shape", &Model::getGlobalDiscretization,
	"Global discretization (in MPI environement)")
	.def_property_readonly("boundary_shape",
	&Model::getBoundaryDiscretization,
	"Number of points on boundary")
	.def_property_readonly("system_size", &Model::getSystemSize,
	"Size of physical domain")
	.def_property_readonly("boundary_system_size",
	&Model::getBoundarySystemSize,
	"Physical size of surface")
	.def_property_readonly("traction",
	(const GridBase<Real>& (Model::*)() const) &
	Model::getTraction,
	"Surface traction field")
	.def_property_readonly("displacement",
	(const GridBase<Real>& (Model::*)() const) &
	Model::getDisplacement,
	"Displacement field");

	py::class_<ModelDumper, PyModelDumper, std::shared_ptr<ModelDumper>>(
	mod, "ModelDumper")
	.def(py::init<>())
	.def("dump", &ModelDumper::dump, "model"_a, "Dump model")
	.def("__lshift__",
	[](ModelDumper& dumper, Model& model) { dumper << model; },
	"Dump model");
	}

	/// Wrap factory for models
	void wrapModelFactory(py::module& mod) {
	py::class_<ModelFactory>(mod, "ModelFactory")
	.def_static("createModel", &ModelFactory::createModel, "model_type"_a,
	"system_size"_a, "global_discretization"_a,
	"Create a new model of a given type, physical size and "
	"global discretization")
	.def_static("createResidual", &ModelFactory::createResidual, "model"_a,
	"sigma_y"_a, "hardening"_a = 0.,
	"Create an isotropic linear hardening residual")
	.def_static("registerVolumeOperators",
	&ModelFactory::registerVolumeOperators, "model"_a,
	"Register Boussinesq and Mindlin operators to model");
	}

	/// Wrap residual class
	void wrapResidual(py::module& mod) {
	// TODO adapt to n-dim
	py::class_<Residual, PyResidual>(mod, "Residual")
	.def(py::init<Model*>())
	.def("computeResidual",
	[](Residual& res, numpy<Real>& x) {
	auto in = instanciateFromNumpy(x);
	res.computeResidual(*in);
	})
	.def("computeStress",
	[](Residual& res, numpy<Real>& x) {
	auto in = instanciateFromNumpy(x);
	res.computeStress(*in);
	})
	.def("updateState",
	[](Residual& res, numpy<Real>& x) {
	auto in = instanciateFromNumpy(x);
	res.updateState(*in);
	})
	.def("computeResidualDisplacement",
	[](Residual& res, numpy<Real>& x) {
	auto in = instanciateFromNumpy(x);
	res.computeResidualDisplacement(*in);
	})
	.def("applyTangent",
	[](Residual& res, numpy<Real>& output, numpy<Real>& input,
	numpy<Real>& current_strain_inc) {
	auto out = instanciateFromNumpy(output);
	auto in = instanciateFromNumpy(input);
	auto inc = instanciateFromNumpy(current_strain_inc);
	res.applyTangent(out, in, *inc);
	},
	"output"_a, "input"_a, "current_strain_increment"_a)
	.def("getVector", &Residual::getVector,
	py::return_value_policy::reference_internal)
	.def("getPlasticStrain", &Residual::getPlasticStrain,
	py::return_value_policy::reference_internal)
	.def("getStress", &Residual::getStress,
	py::return_value_policy::reference_internal)
	.def("setIntegrationMethod", &Residual::setIntegrationMethod, "method"_a,
	"cutoff"_a = 1e-12)
	.def_property("yield_stress", &Residual::getYieldStress,
	&Residual::setYieldStress)
	.def_property("hardening_modulus", &Residual::getHardeningModulus,
	&Residual::setHardeningModulus)
	.def_property_readonly("model", &Residual::getModel);
	}

	void wrapModel(py::module& mod) {
	wrapBEEngine(mod);
	wrapModelClass(mod);
	wrapModelFactory(mod);
	wrapFunctionals(mod);
	wrapResidual(mod);
	wrapIntegralOperator(mod);
	}

	} // namespace wrap

	} // namespace tamaas

model.cppNo OneTemporaryActions

File Metadata

model.cppView Options

Event Timeline

model.cpp
No OneTemporary
Actions

model.cpp
View Options