diff --git a/CMakeLists.txt b/CMakeLists.txt index a68d30b..b4df82a 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,145 +1,146 @@ cmake_minimum_required(VERSION 3.18..3.20) # Basic settings # ============== project(GooseFEM) option(BUILD_ALL "${PROJECT_NAME}: Build tests, Python API & docs" OFF) option(BUILD_TESTS "${PROJECT_NAME}: Build tests" OFF) option(BUILD_PYTHON "${PROJECT_NAME}: Build Python API" OFF) option(BUILD_DOCS "${PROJECT_NAME}: Build docs" OFF) execute_process( COMMAND python -c "from setuptools_scm import get_version; print(get_version())" WORKING_DIRECTORY ${CMAKE_SOURCE_DIR} OUTPUT_VARIABLE PROJECT_VERSION OUTPUT_STRIP_TRAILING_WHITESPACE) message(STATUS "Building ${PROJECT_NAME} ${PROJECT_VERSION}") string(TOUPPER "${PROJECT_NAME}" PROJECT_NAME_UPPER) # Set target # ========== find_package(xtensor REQUIRED) add_library(${PROJECT_NAME} INTERFACE) target_include_directories(${PROJECT_NAME} INTERFACE $ $) target_link_libraries(${PROJECT_NAME} INTERFACE xtensor) target_compile_definitions(${PROJECT_NAME} INTERFACE ${PROJECT_NAME_UPPER}_VERSION="${PROJECT_VERSION}") # Installation # ============ include(CMakePackageConfigHelpers) include(GNUInstallDirs) install(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/include/" DESTINATION include) configure_file("include/${PROJECT_NAME}/version.h" "${CMAKE_CURRENT_BINARY_DIR}/version.h" @ONLY) install(FILES "${CMAKE_CURRENT_BINARY_DIR}/version.h" DESTINATION "include/${PROJECT_NAME}/") install(TARGETS ${PROJECT_NAME} EXPORT ${PROJECT_NAME}-targets) install( EXPORT ${PROJECT_NAME}-targets FILE "${PROJECT_NAME}Targets.cmake" DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}") set(${PROJECT_NAME}_TMP ${CMAKE_SIZEOF_VOID_P}) unset(CMAKE_SIZEOF_VOID_P) write_basic_package_version_file( "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake" VERSION "${PROJECT_VERSION}" COMPATIBILITY AnyNewerVersion) set(CMAKE_SIZEOF_VOID_P ${${PROJECT_NAME}_TMP}) install(FILES "${CMAKE_CURRENT_SOURCE_DIR}/${PROJECT_NAME}Config.cmake" "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake" DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}") configure_file("${CMAKE_CURRENT_SOURCE_DIR}/${PROJECT_NAME}.pc.in" "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}.pc" @ONLY) install(FILES "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}.pc" DESTINATION "${CMAKE_INSTALL_LIBDIR}/pkgconfig/") # Add builds # ========== include("${PROJECT_NAME}Config.cmake") include(CTest) # Tests if(BUILD_TESTS OR BUILD_ALL) enable_testing() add_subdirectory(test/basic) enable_testing() add_subdirectory(test/gmat) endif() # Examples if(BUILD_EXAMPLES) enable_testing() add_subdirectory(docs/examples) endif() # Python API if(BUILD_PYTHON OR BUILD_ALL) find_package(Python REQUIRED COMPONENTS Interpreter Development NumPy) find_package(pybind11 REQUIRED CONFIG) find_package(xtensor-python REQUIRED) + find_package(pyxtensor REQUIRED) pybind11_add_module(mypymod python/main.cpp) set_target_properties(mypymod PROPERTIES OUTPUT_NAME ${PROJECT_NAME}) target_link_libraries(mypymod PUBLIC ${PROJECT_NAME} - pybind11::module xtensor-python Python::NumPy) + pybind11::module xtensor-python Python::NumPy pyxtensor) target_compile_definitions(mypymod PRIVATE VERSION_INFO=${PROJECT_VERSION}) endif() # Documentation if(BUILD_DOCS OR BUILD_ALL) find_package(Doxygen REQUIRED) set(DOXYGEN_EXCLUDE_SYMBOLS detail) set(DOXYGEN_CASE_SENSE_NAMES YES) set(DOXYGEN_USE_MATHJAX YES) set(DOXYGEN_GENERATE_TREEVIEW YES) set(DOXYGEN_JAVADOC_AUTOBRIEF YES) set(DOXYGEN_MACRO_EXPANSION YES) set(DOXYGEN_SOURCE_BROWSER YES) set(DOXYGEN_GENERATE_XML YES) set(DOXYGEN_QUIET YES) set(DOXYGEN_WARN_IF_UNDOCUMENTED YES) set(DOXYGEN_WARN_AS_ERROR YES) set(DOXYGEN_ALIASES "license=@par License:") set(DOXYGEN_USE_MDFILE_AS_MAINPAGE "README.md") set(DOXYGEN_HTML_EXTRA_STYLESHEET "${CMAKE_CURRENT_SOURCE_DIR}/docs/doxystyle/doxygen-awesome.css" "${CMAKE_CURRENT_SOURCE_DIR}/docs/doxystyle/custom.css") set(DOXYGEN_STRIP_FROM_INC_PATH "${CMAKE_CURRENT_SOURCE_DIR}/include") set(DOXYGEN_STRIP_FROM_PATH "${CMAKE_CURRENT_SOURCE_DIR}/include") doxygen_add_docs(docs "${CMAKE_CURRENT_SOURCE_DIR}/include" "README.md") endif() diff --git a/python/Allocate.hpp b/python/Allocate.hpp index 3e6a6dd..547e707 100644 --- a/python/Allocate.hpp +++ b/python/Allocate.hpp @@ -1,35 +1,34 @@ /* ================================================================================================= (c - GPLv3) T.W.J. de Geus (Tom) | tom@geus.me | www.geus.me | github.com/tdegeus/GooseFEM ================================================================================================= */ #include -#include #include -#include +#include namespace py = pybind11; void init_Allocate(py::module& m) { m.def("AsTensor", static_cast (*)( - const xt::xarray&, const std::vector&)>(&GooseFEM::AsTensor), + const xt::pyarray&, const std::vector&)>(&GooseFEM::AsTensor), "See :cpp:func:`GooseFEM::AsTensor`.", py::arg("arg"), py::arg("shape")); m.def("AsTensor", static_cast (*)( - size_t, const xt::xarray&, size_t)>(&GooseFEM::AsTensor), + size_t, const xt::pyarray&, size_t)>(&GooseFEM::AsTensor), "See :cpp:func:`GooseFEM::AsTensor`.", py::arg("rank"), py::arg("arg"), py::arg("n")); m.def("as3d", - &GooseFEM::as3d>, + &GooseFEM::as3d>, "See :cpp:func:`GooseFEM::as3d`.", py::arg("arg")); } diff --git a/python/Element.hpp b/python/Element.hpp index aa09dfc..beafbfb 100644 --- a/python/Element.hpp +++ b/python/Element.hpp @@ -1,27 +1,29 @@ /* ================================================================================================= (c - GPLv3) T.W.J. de Geus (Tom) | tom@geus.me | www.geus.me | github.com/tdegeus/GooseFEM ================================================================================================= */ #include #include +#include +#include #include namespace py = pybind11; void init_Element(py::module& m) { m.def("asElementVector", &GooseFEM::Element::asElementVector, "Convert nodal vector [nnode, ndim] to nodal vector stored per element [nelem, nne, ndim]", py::arg("conn"), py::arg("nodevec")); m.def("assembleElementVector", &GooseFEM::Element::assembleNodeVector, "Assemble nodal vector stored per element [nelem, nne, ndim] to nodal vector [nnode, ndim]", py::arg("conn"), py::arg("elemvec")); } diff --git a/python/ElementHex8.hpp b/python/ElementHex8.hpp index f6b1a5e..f8da367 100644 --- a/python/ElementHex8.hpp +++ b/python/ElementHex8.hpp @@ -1,155 +1,157 @@ /* ================================================================================================= (c - GPLv3) T.W.J. de Geus (Tom) | tom@geus.me | www.geus.me | github.com/tdegeus/GooseFEM ================================================================================================= */ #include #include +#include +#include #include namespace py = pybind11; void init_ElementHex8(py::module& m) { py::class_(m, "Quadrature") .def(py::init&>(), "Quadrature", py::arg("x")) .def(py::init< const xt::xtensor&, const xt::xtensor&, const xt::xtensor&>(), "Quadrature", py::arg("x"), py::arg("xi"), py::arg("w")) .def("update_x", &GooseFEM::Element::Hex8::Quadrature::update_x, "Update the nodal positions") .def("dV", &GooseFEM::Element::Hex8::Quadrature::dV, "Integration point volume (qscalar)") .def("GradN_vector", py::overload_cast&>( &GooseFEM::Element::Hex8::Quadrature::GradN_vector, py::const_), "Dyadic product, returns 'qtensor'", py::arg("elemvec")) .def("GradN_vector_T", py::overload_cast&>( &GooseFEM::Element::Hex8::Quadrature::GradN_vector_T, py::const_), "Dyadic product, returns 'qtensor'", py::arg("elemvec")) .def("SymGradN_vector", py::overload_cast&>( &GooseFEM::Element::Hex8::Quadrature::SymGradN_vector, py::const_), "Dyadic product, returns 'qtensor'", py::arg("elemvec")) .def("Int_N_scalar_NT_dV", py::overload_cast&>( &GooseFEM::Element::Hex8::Quadrature::Int_N_scalar_NT_dV, py::const_), "Integration, returns 'elemmat'", py::arg("qscalar")) .def("Int_gradN_dot_tensor2_dV", py::overload_cast&>( &GooseFEM::Element::Hex8::Quadrature::Int_gradN_dot_tensor2_dV, py::const_), "Integration, returns 'elemvec'", py::arg("qtensor")) .def("Int_gradN_dot_tensor4_dot_gradNT_dV", py::overload_cast&>( &GooseFEM::Element::Hex8::Quadrature::Int_gradN_dot_tensor4_dot_gradNT_dV, py::const_), "Integration, returns 'elemvec'", py::arg("qtensor")) // Derived from QuadratureBase .def("nelem", &GooseFEM::Element::Hex8::Quadrature::nelem, "Number of elements") .def("nne", &GooseFEM::Element::Hex8::Quadrature::nne, "Number of nodes per element") .def("ndim", &GooseFEM::Element::Hex8::Quadrature::ndim, "Number of dimensions") .def("nip", &GooseFEM::Element::Hex8::Quadrature::nip, "Number of integration points") .def("AsTensor", (xt::xarray(GooseFEM::Element::Hex8::Quadrature::*)( size_t, const xt::xtensor&) const) &GooseFEM::Element::Hex8::Quadrature::AsTensor, "Convert 'qscalar' to 'qtensor' of certain rank") .def("shape_elemvec", &GooseFEM::Element::Hex8::Quadrature::shape_elemvec, "Shape of 'elemvec'") .def("shape_elemmat", &GooseFEM::Element::Hex8::Quadrature::shape_elemmat, "Shape of 'elemmat'") .def("shape_qtensor", (std::vector(GooseFEM::Element::Hex8::Quadrature::*)(size_t) const) &GooseFEM::Element::Hex8::Quadrature::shape_qtensor, "Shape of 'qtensor'", py::arg("rank")) .def("shape_qscalar", &GooseFEM::Element::Hex8::Quadrature::shape_qscalar, "Shape of 'qscalar'") // Deprecated .def("AllocateQtensor", (xt::xarray(GooseFEM::Element::Hex8::Quadrature::*)(size_t) const) &GooseFEM::Element::Hex8::Quadrature::allocate_qtensor, "Allocate 'qtensor'", py::arg("rank")) .def("AllocateQtensor", (xt::xarray(GooseFEM::Element::Hex8::Quadrature::*)(size_t, double) const) &GooseFEM::Element::Hex8::Quadrature::allocate_qtensor, "Allocate 'qtensor'", py::arg("rank"), py::arg("val")) .def("AllocateQscalar", py::overload_cast<>( &GooseFEM::Element::Hex8::Quadrature::allocate_qscalar, py::const_), "Allocate 'qscalar'") .def("AllocateQscalar", py::overload_cast( &GooseFEM::Element::Hex8::Quadrature::allocate_qscalar, py::const_), "Allocate 'qscalar'", py::arg("val")) .def("__repr__", [](const GooseFEM::Element::Hex8::Quadrature&) { return ""; }); } void init_ElementHex8Gauss(py::module& m) { m.def("nip", &GooseFEM::Element::Hex8::Gauss::nip, "Return number of integration point"); m.def("xi", &GooseFEM::Element::Hex8::Gauss::xi, "Return integration point coordinates"); m.def("w", &GooseFEM::Element::Hex8::Gauss::w, "Return integration point weights"); } void init_ElementHex8Nodal(py::module& m) { m.def("nip", &GooseFEM::Element::Hex8::Nodal::nip, "Return number of integration point"); m.def("xi", &GooseFEM::Element::Hex8::Nodal::xi, "Return integration point coordinates"); m.def("w", &GooseFEM::Element::Hex8::Nodal::w, "Return integration point weights"); } diff --git a/python/ElementQuad4.hpp b/python/ElementQuad4.hpp index 16289b6..5de3639 100644 --- a/python/ElementQuad4.hpp +++ b/python/ElementQuad4.hpp @@ -1,185 +1,187 @@ /* ================================================================================================= (c - GPLv3) T.W.J. de Geus (Tom) | tom@geus.me | www.geus.me | github.com/tdegeus/GooseFEM ================================================================================================= */ #include #include +#include +#include #include namespace py = pybind11; void init_ElementQuad4(py::module& m) { py::class_(m, "Quadrature") .def(py::init&>(), "Quadrature", py::arg("x")) .def(py::init< const xt::xtensor&, const xt::xtensor&, const xt::xtensor&>(), "Quadrature", py::arg("x"), py::arg("xi"), py::arg("w")) .def("update_x", &GooseFEM::Element::Quad4::Quadrature::update_x, "Update the nodal positions") .def("dV", &GooseFEM::Element::Quad4::Quadrature::dV, "Integration point volume (qscalar)") .def("InterpQuad_vector", &GooseFEM::Element::Quad4::Quadrature::InterpQuad_vector, "See :cpp:class:`GooseFEM::Quad4::Quadrature::InterpQuad_vector`.", py::arg("elemvec")) .def("GradN_vector", py::overload_cast&>( &GooseFEM::Element::Quad4::Quadrature::GradN_vector, py::const_), "Dyadic product, returns 'qtensor'", py::arg("elemvec")) .def("GradN_vector_T", py::overload_cast&>( &GooseFEM::Element::Quad4::Quadrature::GradN_vector_T, py::const_), "Dyadic product, returns 'qtensor'", py::arg("elemvec")) .def("SymGradN_vector", py::overload_cast&>( &GooseFEM::Element::Quad4::Quadrature::SymGradN_vector, py::const_), "Dyadic product, returns 'qtensor'", py::arg("elemvec")) .def("Int_N_vector_dV", &GooseFEM::Element::Quad4::Quadrature::Int_N_vector_dV, "See :cpp:class:`GooseFEM::Quad4::Quadrature::Int_N_vector_dV`.", py::arg("qvector")) .def("Int_N_scalar_NT_dV", py::overload_cast&>( &GooseFEM::Element::Quad4::Quadrature::Int_N_scalar_NT_dV, py::const_), "Integration, returns 'elemmat'", py::arg("qscalar")) .def("Int_gradN_dot_tensor2_dV", py::overload_cast&>( &GooseFEM::Element::Quad4::Quadrature::Int_gradN_dot_tensor2_dV, py::const_), "Integration, returns 'elemvec'", py::arg("qtensor")) .def("Int_gradN_dot_tensor4_dot_gradNT_dV", py::overload_cast&>( &GooseFEM::Element::Quad4::Quadrature::Int_gradN_dot_tensor4_dot_gradNT_dV, py::const_), "Integration, returns 'elemvec'", py::arg("qtensor")) // Derived from QuadratureBase .def("nelem", &GooseFEM::Element::Quad4::Quadrature::nelem, "Number of elements") .def("nne", &GooseFEM::Element::Quad4::Quadrature::nne, "Number of nodes per element") .def("ndim", &GooseFEM::Element::Quad4::Quadrature::ndim, "Number of dimensions") .def("nip", &GooseFEM::Element::Quad4::Quadrature::nip, "Number of integration points") .def("AsTensor", (xt::xarray(GooseFEM::Element::Quad4::Quadrature::*)( size_t, const xt::xtensor&) const) &GooseFEM::Element::Quad4::Quadrature::AsTensor, "Convert 'qscalar' to 'qtensor' of certain rank") .def("shape_elemvec", &GooseFEM::Element::Quad4::Quadrature::shape_elemvec, "Shape of 'elemvec'") .def("shape_elemmat", &GooseFEM::Element::Quad4::Quadrature::shape_elemmat, "Shape of 'elemmat'") .def("shape_qtensor", (std::vector(GooseFEM::Element::Quad4::Quadrature::*)(size_t) const) &GooseFEM::Element::Quad4::Quadrature::shape_qtensor, "Shape of 'qtensor'", py::arg("rank")) .def("shape_qscalar", &GooseFEM::Element::Quad4::Quadrature::shape_qscalar, "Shape of 'qscalar'") // Deprecated .def("ShapeQtensor", (std::vector(GooseFEM::Element::Quad4::Quadrature::*)(size_t) const) &GooseFEM::Element::Quad4::Quadrature::shape_qtensor, "Shape of 'qtensor'", py::arg("rank")) .def("ShapeQscalar", &GooseFEM::Element::Quad4::Quadrature::shape_qscalar, "Shape of 'qscalar'") .def("AllocateQtensor", (xt::xarray(GooseFEM::Element::Quad4::Quadrature::*)(size_t) const) &GooseFEM::Element::Quad4::Quadrature::allocate_qtensor, "Allocate 'qtensor'", py::arg("rank")) .def("AllocateQtensor", (xt::xarray(GooseFEM::Element::Quad4::Quadrature::*)(size_t, double) const) &GooseFEM::Element::Quad4::Quadrature::allocate_qtensor, "Allocate 'qtensor'", py::arg("rank"), py::arg("val")) .def("AllocateQscalar", py::overload_cast<>( &GooseFEM::Element::Quad4::Quadrature::allocate_qscalar, py::const_), "Allocate 'qscalar'") .def("AllocateQscalar", py::overload_cast( &GooseFEM::Element::Quad4::Quadrature::allocate_qscalar, py::const_), "Allocate 'qscalar'", py::arg("val")) .def("__repr__", [](const GooseFEM::Element::Quad4::Quadrature&) { return ""; }); } void init_ElementQuad4Gauss(py::module& m) { m.def("nip", &GooseFEM::Element::Quad4::Gauss::nip, "Return number of integration point"); m.def("xi", &GooseFEM::Element::Quad4::Gauss::xi, "Return integration point coordinates"); m.def("w", &GooseFEM::Element::Quad4::Gauss::w, "Return integration point weights"); } void init_ElementQuad4Nodal(py::module& m) { m.def("nip", &GooseFEM::Element::Quad4::Nodal::nip, "Return number of integration point"); m.def("xi", &GooseFEM::Element::Quad4::Nodal::xi, "Return integration point coordinates"); m.def("w", &GooseFEM::Element::Quad4::Nodal::w, "Return integration point weights"); } void init_ElementQuad4MidPoint(py::module& m) { m.def("nip", &GooseFEM::Element::Quad4::MidPoint::nip, "Return number of integration point"); m.def("xi", &GooseFEM::Element::Quad4::MidPoint::xi, "Return integration point coordinates"); m.def("w", &GooseFEM::Element::Quad4::MidPoint::w, "Return integration point weights"); } diff --git a/python/ElementQuad4Axisymmetric.hpp b/python/ElementQuad4Axisymmetric.hpp index e4726a2..9eda16f 100644 --- a/python/ElementQuad4Axisymmetric.hpp +++ b/python/ElementQuad4Axisymmetric.hpp @@ -1,138 +1,140 @@ /* ================================================================================================= (c - GPLv3) T.W.J. de Geus (Tom) | tom@geus.me | www.geus.me | github.com/tdegeus/GooseFEM ================================================================================================= */ #include #include +#include +#include #include namespace py = pybind11; void init_ElementQuad4Axisymmetric(py::module& m) { py::class_(m, "QuadratureAxisymmetric") .def(py::init&>(), "QuadratureAxisymmetric", py::arg("x")) .def(py::init< const xt::xtensor&, const xt::xtensor&, const xt::xtensor&>(), "QuadratureAxisymmetric", py::arg("x"), py::arg("xi"), py::arg("w")) .def("update_x", &GooseFEM::Element::Quad4::QuadratureAxisymmetric::update_x, "Update the nodal positions") .def("dV", &GooseFEM::Element::Quad4::QuadratureAxisymmetric::dV, "Integration point volume (qscalar)") .def("GradN_vector", py::overload_cast&>( &GooseFEM::Element::Quad4::QuadratureAxisymmetric::GradN_vector, py::const_), "Dyadic product, returns 'qtensor'", py::arg("elemvec")) .def("GradN_vector_T", py::overload_cast&>( &GooseFEM::Element::Quad4::QuadratureAxisymmetric::GradN_vector_T, py::const_), "Dyadic product, returns 'qtensor'", py::arg("elemvec")) .def("SymGradN_vector", py::overload_cast&>( &GooseFEM::Element::Quad4::QuadratureAxisymmetric::SymGradN_vector, py::const_), "Dyadic product, returns 'qtensor'", py::arg("elemvec")) .def("Int_N_scalar_NT_dV", py::overload_cast&>( &GooseFEM::Element::Quad4::QuadratureAxisymmetric::Int_N_scalar_NT_dV, py::const_), "Integration, returns 'elemmat'", py::arg("qscalar")) .def("Int_gradN_dot_tensor2_dV", py::overload_cast&>( &GooseFEM::Element::Quad4::QuadratureAxisymmetric::Int_gradN_dot_tensor2_dV, py::const_), "Integration, returns 'elemvec'", py::arg("qtensor")) .def("Int_gradN_dot_tensor4_dot_gradNT_dV", py::overload_cast&>( &GooseFEM::Element::Quad4::QuadratureAxisymmetric::Int_gradN_dot_tensor4_dot_gradNT_dV, py::const_), "Integration, returns 'elemvec'", py::arg("qtensor")) // Derived from QuadratureBase .def("nelem", &GooseFEM::Element::Quad4::QuadratureAxisymmetric::nelem, "Number of elements") .def("nne", &GooseFEM::Element::Quad4::QuadratureAxisymmetric::nne, "Number of nodes per element") .def("ndim", &GooseFEM::Element::Quad4::QuadratureAxisymmetric::ndim, "Number of dimensions") .def("nip", &GooseFEM::Element::Quad4::QuadratureAxisymmetric::nip, "Number of integration points") .def("AsTensor", (xt::xarray(GooseFEM::Element::Quad4::QuadratureAxisymmetric::*)( size_t, const xt::xtensor&) const) &GooseFEM::Element::Quad4::QuadratureAxisymmetric::AsTensor, "Convert 'qscalar' to 'qtensor' of certain rank") .def("shape_elemvec", &GooseFEM::Element::Quad4::QuadratureAxisymmetric::shape_elemvec, "Shape of 'elemvec'") .def("shape_elemmat", &GooseFEM::Element::Quad4::QuadratureAxisymmetric::shape_elemmat, "Shape of 'elemmat'") .def("shape_qtensor", (std::vector(GooseFEM::Element::Quad4::QuadratureAxisymmetric::*)(size_t) const) &GooseFEM::Element::Quad4::QuadratureAxisymmetric::shape_qtensor, "Shape of 'qtensor'", py::arg("rank")) .def("shape_qscalar", &GooseFEM::Element::Quad4::QuadratureAxisymmetric::shape_qscalar, "Shape of 'qscalar'") // Deprecated .def("AllocateQtensor", (xt::xarray(GooseFEM::Element::Quad4::QuadratureAxisymmetric::*)(size_t) const) &GooseFEM::Element::Quad4::QuadratureAxisymmetric::allocate_qtensor, "Allocate 'qtensor'", py::arg("rank")) .def("AllocateQtensor", (xt::xarray(GooseFEM::Element::Quad4::QuadratureAxisymmetric::*)(size_t, double) const) &GooseFEM::Element::Quad4::QuadratureAxisymmetric::allocate_qtensor, "Allocate 'qtensor'", py::arg("rank"), py::arg("val")) .def("AllocateQscalar", py::overload_cast<>( &GooseFEM::Element::Quad4::QuadratureAxisymmetric::allocate_qscalar, py::const_), "Allocate 'qscalar'") .def("AllocateQscalar", py::overload_cast( &GooseFEM::Element::Quad4::QuadratureAxisymmetric::allocate_qscalar, py::const_), "Allocate 'qscalar'", py::arg("val")) .def("__repr__", [](const GooseFEM::Element::Quad4::QuadratureAxisymmetric&) { return ""; }); } diff --git a/python/ElementQuad4Planar.hpp b/python/ElementQuad4Planar.hpp index 2be1362..ec3e1cd 100644 --- a/python/ElementQuad4Planar.hpp +++ b/python/ElementQuad4Planar.hpp @@ -1,137 +1,139 @@ /* ================================================================================================= (c - GPLv3) T.W.J. de Geus (Tom) | tom@geus.me | www.geus.me | github.com/tdegeus/GooseFEM ================================================================================================= */ #include #include +#include +#include #include namespace py = pybind11; void init_ElementQuad4Planar(py::module& m) { py::class_(m, "QuadraturePlanar") .def(py::init&>(), "QuadraturePlanar", py::arg("x")) .def(py::init< const xt::xtensor&, const xt::xtensor&, const xt::xtensor&>(), "QuadraturePlanar", py::arg("x"), py::arg("xi"), py::arg("w")) .def("update_x", &GooseFEM::Element::Quad4::QuadraturePlanar::update_x, "Update the nodal positions") .def("dV", &GooseFEM::Element::Quad4::QuadraturePlanar::dV, "Integration point volume (qscalar)") .def("GradN_vector", py::overload_cast&>( &GooseFEM::Element::Quad4::QuadraturePlanar::GradN_vector, py::const_), "Dyadic product, returns 'qtensor'", py::arg("elemvec")) .def("GradN_vector_T", py::overload_cast&>( &GooseFEM::Element::Quad4::QuadraturePlanar::GradN_vector_T, py::const_), "Dyadic product, returns 'qtensor'", py::arg("elemvec")) .def("SymGradN_vector", py::overload_cast&>( &GooseFEM::Element::Quad4::QuadraturePlanar::SymGradN_vector, py::const_), "Dyadic product, returns 'qtensor'", py::arg("elemvec")) .def("Int_N_scalar_NT_dV", py::overload_cast&>( &GooseFEM::Element::Quad4::QuadraturePlanar::Int_N_scalar_NT_dV, py::const_), "Integration, returns 'elemmat'", py::arg("qscalar")) .def("Int_gradN_dot_tensor2_dV", py::overload_cast&>( &GooseFEM::Element::Quad4::QuadraturePlanar::Int_gradN_dot_tensor2_dV, py::const_), "Integration, returns 'elemvec'", py::arg("qtensor")) .def("Int_gradN_dot_tensor4_dot_gradNT_dV", py::overload_cast&>( &GooseFEM::Element::Quad4::QuadraturePlanar::Int_gradN_dot_tensor4_dot_gradNT_dV, py::const_), "Integration, returns 'elemvec'", py::arg("qtensor")) // Derived from QuadratureBase .def("nelem", &GooseFEM::Element::Quad4::QuadraturePlanar::nelem, "Number of elements") .def("nne", &GooseFEM::Element::Quad4::QuadraturePlanar::nne, "Number of nodes per element") .def("ndim", &GooseFEM::Element::Quad4::QuadraturePlanar::ndim, "Number of dimensions") .def("nip", &GooseFEM::Element::Quad4::QuadraturePlanar::nip, "Number of integration points") .def("AsTensor", (xt::xarray(GooseFEM::Element::Quad4::QuadraturePlanar::*)( size_t, const xt::xtensor&) const) &GooseFEM::Element::Quad4::QuadraturePlanar::AsTensor, "Convert 'qscalar' to 'qtensor' of certain rank") .def("shape_elemvec", &GooseFEM::Element::Quad4::QuadraturePlanar::shape_elemvec, "Shape of 'elemvec'") .def("shape_elemmat", &GooseFEM::Element::Quad4::QuadraturePlanar::shape_elemmat, "Shape of 'elemmat'") .def("shape_qtensor", (std::vector(GooseFEM::Element::Quad4::QuadraturePlanar::*)(size_t) const) &GooseFEM::Element::Quad4::QuadraturePlanar::shape_qtensor, "Shape of 'qtensor'", py::arg("rank")) .def("shape_qscalar", &GooseFEM::Element::Quad4::QuadraturePlanar::shape_qscalar, "Shape of 'qscalar'") // Deprecated .def("AllocateQtensor", (xt::xarray(GooseFEM::Element::Quad4::QuadraturePlanar::*)(size_t) const) &GooseFEM::Element::Quad4::QuadraturePlanar::allocate_qtensor, "Allocate 'qtensor'", py::arg("rank")) .def("AllocateQtensor", (xt::xarray(GooseFEM::Element::Quad4::QuadraturePlanar::*)(size_t, double) const) &GooseFEM::Element::Quad4::QuadraturePlanar::allocate_qtensor, "Allocate 'qtensor'", py::arg("rank"), py::arg("val")) .def("AllocateQscalar", py::overload_cast<>( &GooseFEM::Element::Quad4::QuadraturePlanar::allocate_qscalar, py::const_), "Allocate 'qscalar'") .def("AllocateQscalar", py::overload_cast( &GooseFEM::Element::Quad4::QuadraturePlanar::allocate_qscalar, py::const_), "Allocate 'qscalar'", py::arg("val")) .def("__repr__", [](const GooseFEM::Element::Quad4::QuadraturePlanar&) { return ""; }); } diff --git a/python/Matrix.hpp b/python/Matrix.hpp index 7a0360c..1411d0f 100644 --- a/python/Matrix.hpp +++ b/python/Matrix.hpp @@ -1,104 +1,106 @@ /* ================================================================================================= (c - GPLv3) T.W.J. de Geus (Tom) | tom@geus.me | www.geus.me | github.com/tdegeus/GooseFEM ================================================================================================= */ #include #include #include #include +#include +#include #include namespace py = pybind11; void init_Matrix(py::module& m) { py::class_(m, "Matrix") .def( py::init&, const xt::xtensor&>(), "Sparse matrix", py::arg("conn"), py::arg("dofs")) .def("nelem", &GooseFEM::Matrix::nelem, "See :cpp:func:`GooseFEM::Matrix::nelem`.") .def("nne", &GooseFEM::Matrix::nne, "See :cpp:func:`GooseFEM::Matrix::nne`.") .def("nnode", &GooseFEM::Matrix::nnode, "See :cpp:func:`GooseFEM::Matrix::nnode`.") .def("ndim", &GooseFEM::Matrix::ndim, "See :cpp:func:`GooseFEM::Matrix::ndim`.") .def("ndof", &GooseFEM::Matrix::ndof, "See :cpp:func:`GooseFEM::Matrix::ndof`.") .def("dofs", &GooseFEM::Matrix::dofs, "See :cpp:func:`GooseFEM::Matrix::dofs`.") .def("assemble", &GooseFEM::Matrix::assemble, "See :cpp:func:`GooseFEM::Matrix::assemble`.", py::arg("elemmat")) .def("set", &GooseFEM::Matrix::set, "See :cpp:func:`GooseFEM::Matrix::set`.", py::arg("rows"), py::arg("cols"), py::arg("matrix")) .def("add", &GooseFEM::Matrix::add, "See :cpp:func:`GooseFEM::Matrix::add`.", py::arg("rows"), py::arg("cols"), py::arg("matrix")) .def("Todense", &GooseFEM::Matrix::Todense, "See :cpp:func:`GooseFEM::Matrix::Todense`.") .def("Dot", py::overload_cast&>(&GooseFEM::Matrix::Dot, py::const_), "See :cpp:func:`GooseFEM::Matrix::Dot`.", py::arg("x")) .def("Dot", py::overload_cast&>(&GooseFEM::Matrix::Dot, py::const_), "See :cpp:func:`GooseFEM::Matrix::Dot`.", py::arg("x")) .def("__repr__", [](const GooseFEM::Matrix&) { return ""; }); py::class_>(m, "MatrixSolver") .def(py::init<>(), "Sparse matrix solver") .def("Solve", py::overload_cast&>( &GooseFEM::MatrixSolver<>::Solve), "See :cpp:func:`GooseFEM::MatrixSolver::Solve`.", py::arg("A"), py::arg("b")) .def("Solve", py::overload_cast&>( &GooseFEM::MatrixSolver<>::Solve), "See :cpp:func:`GooseFEM::MatrixSolver::Solve`.", py::arg("A"), py::arg("b")) .def("__repr__", [](const GooseFEM::MatrixSolver<>&) { return ""; }); } diff --git a/python/MatrixDiagonal.hpp b/python/MatrixDiagonal.hpp index 730c943..d32c584 100644 --- a/python/MatrixDiagonal.hpp +++ b/python/MatrixDiagonal.hpp @@ -1,87 +1,89 @@ /* ================================================================================================= (c - GPLv3) T.W.J. de Geus (Tom) | tom@geus.me | www.geus.me | github.com/tdegeus/GooseFEM ================================================================================================= */ #include #include +#include +#include #include namespace py = pybind11; void init_MatrixDiagonal(py::module& m) { py::class_(m, "MatrixDiagonal") .def( py::init&, const xt::xtensor&>(), "Diagonal matrix", py::arg("conn"), py::arg("dofs")) .def("nelem", &GooseFEM::MatrixDiagonal::nelem, "See :cpp:func:`GooseFEM::MatrixDiagonal::nelem`.") .def("nne", &GooseFEM::MatrixDiagonal::nne, "See :cpp:func:`GooseFEM::MatrixDiagonal::nne`.") .def("nnode", &GooseFEM::MatrixDiagonal::nnode, "See :cpp:func:`GooseFEM::MatrixDiagonal::nnode`.") .def("ndim", &GooseFEM::MatrixDiagonal::ndim, "See :cpp:func:`GooseFEM::MatrixDiagonal::ndim`.") .def("ndof", &GooseFEM::MatrixDiagonal::ndof, "See :cpp:func:`GooseFEM::MatrixDiagonal::ndof`.") .def("dofs", &GooseFEM::MatrixDiagonal::dofs, "See :cpp:func:`GooseFEM::MatrixDiagonal::dofs`.") .def("assemble", &GooseFEM::MatrixDiagonal::assemble, "See :cpp:func:`GooseFEM::MatrixDiagonal::assemble`.", py::arg("elemmat")) .def("set", &GooseFEM::MatrixDiagonal::set, "See :cpp:func:`GooseFEM::MatrixDiagonal::set`.", py::arg("A")) .def("Todiagonal", &GooseFEM::MatrixDiagonal::Todiagonal, "See :cpp:func:`GooseFEM::MatrixDiagonal::Todiagonal`.") .def("Dot", py::overload_cast&>( &GooseFEM::MatrixDiagonal::Dot, py::const_), "See :cpp:func:`GooseFEM::MatrixDiagonal::Dot`.", py::arg("x")) .def("Dot", py::overload_cast&>( &GooseFEM::MatrixDiagonal::Dot, py::const_), "See :cpp:func:`GooseFEM::MatrixDiagonal::Dot`.", py::arg("x")) .def("Solve", py::overload_cast&>(&GooseFEM::MatrixDiagonal::Solve), "See :cpp:func:`GooseFEM::MatrixDiagonal::Solve`.", py::arg("b")) .def("Solve", py::overload_cast&>(&GooseFEM::MatrixDiagonal::Solve), "See :cpp:func:`GooseFEM::MatrixDiagonal::Solve`.", py::arg("b")) .def("__repr__", [](const GooseFEM::MatrixDiagonal&) { return ""; }); } diff --git a/python/MatrixDiagonalPartitioned.hpp b/python/MatrixDiagonalPartitioned.hpp index 90b43be..0e34148 100644 --- a/python/MatrixDiagonalPartitioned.hpp +++ b/python/MatrixDiagonalPartitioned.hpp @@ -1,88 +1,90 @@ /* ================================================================================================= (c - GPLv3) T.W.J. de Geus (Tom) | tom@geus.me | www.geus.me | github.com/tdegeus/GooseFEM ================================================================================================= */ #include #include +#include +#include #include namespace py = pybind11; void init_MatrixDiagonalPartitioned(py::module& m) { py::class_(m, "MatrixDiagonalPartitioned") .def(py::init< const xt::xtensor&, const xt::xtensor&, const xt::xtensor&>(), "Diagonal, partitioned, matrix", py::arg("conn"), py::arg("dofs"), py::arg("iip")) .def("nnu", &GooseFEM::MatrixDiagonalPartitioned::nnu, "See :cpp:func:`GooseFEM::MatrixDiagonalPartitioned::nnu`.") .def("nnp", &GooseFEM::MatrixDiagonalPartitioned::nnp, "See :cpp:func:`GooseFEM::MatrixDiagonalPartitioned::nnp`.") .def("iiu", &GooseFEM::MatrixDiagonalPartitioned::iiu, "See :cpp:func:`GooseFEM::MatrixDiagonalPartitioned::iiu`.") .def("iip", &GooseFEM::MatrixDiagonalPartitioned::iip, "See :cpp:func:`GooseFEM::MatrixDiagonalPartitioned::iip`.") .def("Dot_u", py::overload_cast&, const xt::xtensor&>( &GooseFEM::MatrixDiagonalPartitioned::Dot_u, py::const_), "See :cpp:func:`GooseFEM::MatrixDiagonalPartitioned::Dot_u`.", py::arg("x_u"), py::arg("x_p")) .def("Dot_p", py::overload_cast&, const xt::xtensor&>( &GooseFEM::MatrixDiagonalPartitioned::Dot_p, py::const_), "See :cpp:func:`GooseFEM::MatrixDiagonalPartitioned::Dot_p`.", py::arg("x_u"), py::arg("x_p")) .def("Solve_u", py::overload_cast&, const xt::xtensor&>( &GooseFEM::MatrixDiagonalPartitioned::Solve_u), "See :cpp:func:`GooseFEM::MatrixDiagonalPartitioned::Solve_u`.", py::arg("b_u"), py::arg("x_p")) .def("Reaction", py::overload_cast&, const xt::xtensor&>( &GooseFEM::MatrixDiagonalPartitioned::Reaction, py::const_), "See :cpp:func:`GooseFEM::MatrixDiagonalPartitioned::Reaction`.", py::arg("x"), py::arg("b")) .def("Reaction", py::overload_cast&, const xt::xtensor&>( &GooseFEM::MatrixDiagonalPartitioned::Reaction, py::const_), "See :cpp:func:`GooseFEM::MatrixDiagonalPartitioned::Reaction`.", py::arg("x"), py::arg("b")) .def("Reaction_p", py::overload_cast&, const xt::xtensor&>( &GooseFEM::MatrixDiagonalPartitioned::Reaction_p, py::const_), "See :cpp:func:`GooseFEM::MatrixDiagonalPartitioned::Reaction_p`.", py::arg("x_u"), py::arg("x_p")) .def("__repr__", [](const GooseFEM::MatrixDiagonalPartitioned&) { return ""; }); } diff --git a/python/MatrixPartitioned.hpp b/python/MatrixPartitioned.hpp index 6c847ec..218d550 100644 --- a/python/MatrixPartitioned.hpp +++ b/python/MatrixPartitioned.hpp @@ -1,107 +1,109 @@ /* ================================================================================================= (c - GPLv3) T.W.J. de Geus (Tom) | tom@geus.me | www.geus.me | github.com/tdegeus/GooseFEM ================================================================================================= */ #include #include #include #include +#include +#include #include namespace py = pybind11; void init_MatrixPartitioned(py::module& m) { py::class_(m, "MatrixPartitioned") .def(py::init< const xt::xtensor&, const xt::xtensor&, const xt::xtensor&>(), "Sparse, partitioned, matrix", py::arg("conn"), py::arg("dofs"), py::arg("iip")) .def("nnu", &GooseFEM::MatrixPartitioned::nnu, "See :cpp:func:`GooseFEM::MatrixPartitioned::nnu`.") .def("nnp", &GooseFEM::MatrixPartitioned::nnp, "See :cpp:func:`GooseFEM::MatrixPartitioned::nnp`.") .def("iiu", &GooseFEM::MatrixPartitioned::iiu, "See :cpp:func:`GooseFEM::MatrixPartitioned::iiu`.") .def("iip", &GooseFEM::MatrixPartitioned::iip, "See :cpp:func:`GooseFEM::MatrixPartitioned::iip`.") .def("Reaction", py::overload_cast&, const xt::xtensor&>( &GooseFEM::MatrixPartitioned::Reaction, py::const_), "See :cpp:func:`GooseFEM::MatrixPartitioned::Reaction`.", py::arg("x"), py::arg("b")) .def("Reaction", py::overload_cast&, const xt::xtensor&>( &GooseFEM::MatrixPartitioned::Reaction, py::const_), "See :cpp:func:`GooseFEM::MatrixPartitioned::Reaction`.", py::arg("x"), py::arg("b")) .def("Reaction_p", py::overload_cast&, const xt::xtensor&>( &GooseFEM::MatrixPartitioned::Reaction_p, py::const_), "See :cpp:func:`GooseFEM::MatrixPartitioned::Reaction_p`.", py::arg("x_u"), py::arg("x_p")) .def("__repr__", [](const GooseFEM::MatrixPartitioned&) { return ""; }); py::class_>(m, "MatrixPartitionedSolver") .def(py::init<>(), "Sparse, partitioned, matrix solver") .def("Solve", py::overload_cast< GooseFEM::MatrixPartitioned&, const xt::xtensor&, const xt::xtensor&>(&GooseFEM::MatrixPartitionedSolver<>::Solve), "See :cpp:func:`GooseFEM::MatrixPartitionedSolver::Solve`.", py::arg("matrix"), py::arg("b"), py::arg("x")) .def("Solve", py::overload_cast< GooseFEM::MatrixPartitioned&, const xt::xtensor&, const xt::xtensor&>(&GooseFEM::MatrixPartitionedSolver<>::Solve), "See :cpp:func:`GooseFEM::MatrixPartitionedSolver::Solve`.", py::arg("matrix"), py::arg("b"), py::arg("x")) .def("Solve_u", py::overload_cast< GooseFEM::MatrixPartitioned&, const xt::xtensor&, const xt::xtensor&>(&GooseFEM::MatrixPartitionedSolver<>::Solve_u), "See :cpp:func:`GooseFEM::MatrixPartitionedSolver::Solve_u`.", py::arg("matrix"), py::arg("b_u"), py::arg("x_p")) .def("__repr__", [](const GooseFEM::MatrixPartitionedSolver<>&) { return ""; }); } diff --git a/python/MatrixPartitionedTyings.hpp b/python/MatrixPartitionedTyings.hpp index 91860b6..927c866 100644 --- a/python/MatrixPartitionedTyings.hpp +++ b/python/MatrixPartitionedTyings.hpp @@ -1,112 +1,114 @@ /* ================================================================================================= (c - GPLv3) T.W.J. de Geus (Tom) | tom@geus.me | www.geus.me | github.com/tdegeus/GooseFEM ================================================================================================= */ #include #include #include #include +#include +#include #include namespace py = pybind11; void init_MatrixPartitionedTyings(py::module& m) { py::class_(m, "MatrixPartitionedTyings") .def( py::init< const xt::xtensor&, const xt::xtensor&, const Eigen::SparseMatrix&, const Eigen::SparseMatrix&>(), "Sparse, partitioned, matrix", py::arg("conn"), py::arg("dofs"), py::arg("Cdu"), py::arg("Cdp")) .def("nelem", &GooseFEM::MatrixPartitionedTyings::nelem, "Number of element") .def("nne", &GooseFEM::MatrixPartitionedTyings::nne, "Number of nodes per element") .def("nnode", &GooseFEM::MatrixPartitionedTyings::nnode, "Number of nodes") .def("ndim", &GooseFEM::MatrixPartitionedTyings::ndim, "Number of dimensions") .def("ndof", &GooseFEM::MatrixPartitionedTyings::ndof, "Number of DOFs") .def("nnu", &GooseFEM::MatrixPartitionedTyings::nnu, "Number of unknown DOFs") .def("nnp", &GooseFEM::MatrixPartitionedTyings::nnp, "Number of prescribed DOFs") .def("nni", &GooseFEM::MatrixPartitionedTyings::nni, "Number of independent DOFs") .def("nnd", &GooseFEM::MatrixPartitionedTyings::nnd, "Number of dependent DOFs") .def( "assemble", &GooseFEM::MatrixPartitionedTyings::assemble, "Assemble matrix from 'elemmat", py::arg("elemmat")) .def("dofs", &GooseFEM::MatrixPartitionedTyings::dofs, "Degrees-of-freedom") .def("iiu", &GooseFEM::MatrixPartitionedTyings::iiu, "Unknown DOFs") .def("iip", &GooseFEM::MatrixPartitionedTyings::iip, "Prescribed DOFs") .def("iii", &GooseFEM::MatrixPartitionedTyings::iii, "Independent DOFs") .def("iid", &GooseFEM::MatrixPartitionedTyings::iid, "Dependent DOFs") .def("__repr__", [](const GooseFEM::MatrixPartitionedTyings&) { return ""; }); py::class_>(m, "MatrixPartitionedTyingsSolver") .def(py::init<>(), "Sparse, partitioned, matrix solver") .def( "Solve", py::overload_cast< GooseFEM::MatrixPartitionedTyings&, const xt::xtensor&, const xt::xtensor&>(&GooseFEM::MatrixPartitionedTyingsSolver<>::Solve), "Solve", py::arg("matrix"), py::arg("b"), py::arg("x")) .def( "Solve", py::overload_cast< GooseFEM::MatrixPartitionedTyings&, const xt::xtensor&, const xt::xtensor&>(&GooseFEM::MatrixPartitionedTyingsSolver<>::Solve), "Solve", py::arg("matrix"), py::arg("b"), py::arg("x")) .def( "Solve_u", py::overload_cast< GooseFEM::MatrixPartitionedTyings&, const xt::xtensor&, const xt::xtensor&, const xt::xtensor&>(&GooseFEM::MatrixPartitionedTyingsSolver<>::Solve_u), "Solve_u", py::arg("matrix"), py::arg("b_u"), py::arg("b_d"), py::arg("x_p")) .def("__repr__", [](const GooseFEM::MatrixPartitionedTyingsSolver<>&) { return ""; }); } diff --git a/python/Mesh.hpp b/python/Mesh.hpp index edafd26..1767724 100644 --- a/python/Mesh.hpp +++ b/python/Mesh.hpp @@ -1,433 +1,435 @@ /* ================================================================================================= (c - GPLv3) T.W.J. de Geus (Tom) | tom@geus.me | www.geus.me | github.com/tdegeus/GooseFEM ================================================================================================= */ #include #include +#include +#include #include namespace py = pybind11; void init_Mesh(py::module& m) { py::enum_(m, "ElementType", "ElementType." "See :cpp:enum:`GooseFEM::Mesh::ElementType`.") .value("Unknown", GooseFEM::Mesh::ElementType::Unknown) .value("Tri3", GooseFEM::Mesh::ElementType::Tri3) .value("Quad4", GooseFEM::Mesh::ElementType::Quad4) .value("Hex8", GooseFEM::Mesh::ElementType::Hex8) .export_values(); m.def("overlapping", &GooseFEM::Mesh::overlapping, xt::xtensor>, "Find overlapping nodes." "See :cpp:func:`GooseFEM::Mesh::overlapping`.", py::arg("coor_a"), py::arg("coor_b"), py::arg("rtol") = 1e-5, py::arg("atol") = 1e-8); py::class_(m, "ManualStitch") .def(py::init< const xt::xtensor&, const xt::xtensor&, const xt::xtensor&, const xt::xtensor&, const xt::xtensor&, const xt::xtensor&, bool, double, double>(), "Manually stitch meshes." "See :cpp:class:`GooseFEM::Mesh::ManualStitch`.", py::arg("coor_a"), py::arg("conn_a"), py::arg("overlapping_nodes_a"), py::arg("coor_b"), py::arg("conn_b"), py::arg("overlapping_nodes_b"), py::arg("check_position") = true, py::arg("rtol") = 1e-5, py::arg("atol") = 1e-8) .def("nmesh", &GooseFEM::Mesh::ManualStitch::nmesh, "Number of sub meshes." "See :cpp:func:`GooseFEM::Mesh::ManualStitch::nmesh`.") .def("nnode", &GooseFEM::Mesh::ManualStitch::nnode, "Number of nodes of stitched mesh." "See :cpp:func:`GooseFEM::Mesh::ManualStitch::nnode`.") .def("nelem", &GooseFEM::Mesh::ManualStitch::nelem, "Number of elements of stitched mesh." "See :cpp:func:`GooseFEM::Mesh::ManualStitch::nelem`.") .def("ndim", &GooseFEM::Mesh::ManualStitch::ndim, "Number of dimensions (of stitched mesh)." "See :cpp:func:`GooseFEM::Mesh::ManualStitch::ndim`.") .def("nne", &GooseFEM::Mesh::ManualStitch::nne, "Number of nodes per element (of stitched mesh)." "See :cpp:func:`GooseFEM::Mesh::ManualStitch::nne`.") .def("coor", &GooseFEM::Mesh::ManualStitch::coor, "Coordinates of stitched mesh." "See :cpp:func:`GooseFEM::Mesh::ManualStitch::coor`.") .def("conn", &GooseFEM::Mesh::ManualStitch::conn, "Connectivity of stitched mesh." "See :cpp:func:`GooseFEM::Mesh::ManualStitch::conn`.") .def("dofs", &GooseFEM::Mesh::ManualStitch::dofs, "DOF numbers per node." "See :cpp:func:`GooseFEM::Mesh::ManualStitch::dofs`.") .def("nodemap", py::overload_cast<>( &GooseFEM::Mesh::ManualStitch::nodemap, py::const_), "Node-map for givall sub-meshes." "See :cpp:func:`GooseFEM::Mesh::ManualStitch::nodemap`.") .def("elemmap", py::overload_cast<>( &GooseFEM::Mesh::ManualStitch::elemmap, py::const_), "Element-map for all sub-meshes." "See :cpp:func:`GooseFEM::Mesh::ManualStitch::elemmap`.") .def("nodemap", py::overload_cast( &GooseFEM::Mesh::ManualStitch::nodemap, py::const_), "Node-map for given sub-mesh." "See :cpp:func:`GooseFEM::Mesh::ManualStitch::nodemap`.", py::arg("mesh_index")) .def("elemmap", py::overload_cast( &GooseFEM::Mesh::ManualStitch::elemmap, py::const_), "Element-map for given sub-mesh." "See :cpp:func:`GooseFEM::Mesh::ManualStitch::elemmap`.", py::arg("mesh_index")) .def("nodeset", &GooseFEM::Mesh::ManualStitch::nodeset>, "Convert node-set to the stitched mesh." "See :cpp:func:`GooseFEM::Mesh::ManualStitch::nodeset`.", py::arg("set"), py::arg("mesh_index")) .def("elemset", &GooseFEM::Mesh::ManualStitch::elemset>, "Convert element-set to the stitched mesh." "See :cpp:func:`GooseFEM::Mesh::ManualStitch::elemset`.", py::arg("set"), py::arg("mesh_index")) .def("__repr__", [](const GooseFEM::Mesh::ManualStitch&) { return ""; }); py::class_(m, "Stitch") .def(py::init(), "Stitch meshes." "See :cpp:class:`GooseFEM::Mesh::Stitch`.", py::arg("rtol") = 1e-5, py::arg("atol") = 1e-8) .def("push_back", &GooseFEM::Mesh::Stitch::push_back, xt::xtensor>, "Add mesh to be stitched." "See :cpp:func:`GooseFEM::Mesh::Stitch::push_back`.", py::arg("coor"), py::arg("conn")) .def("nmesh", &GooseFEM::Mesh::Stitch::nmesh, "Number of sub meshes." "See :cpp:func:`GooseFEM::Mesh::Stitch::nmesh`.") .def("nnode", &GooseFEM::Mesh::Stitch::nnode, "Number of nodes of stitched mesh." "See :cpp:func:`GooseFEM::Mesh::Stitch::nnode`.") .def("nelem", &GooseFEM::Mesh::Stitch::nelem, "Number of elements of stitched mesh." "See :cpp:func:`GooseFEM::Mesh::Stitch::nelem`.") .def("ndim", &GooseFEM::Mesh::Stitch::ndim, "Number of dimensions (of stitched mesh)." "See :cpp:func:`GooseFEM::Mesh::Stitch::ndim`.") .def("nne", &GooseFEM::Mesh::Stitch::nne, "Number of nodes per element (of stitched mesh)." "See :cpp:func:`GooseFEM::Mesh::Stitch::nne`.") .def("coor", &GooseFEM::Mesh::Stitch::coor, "Coordinates of stitched mesh." "See :cpp:func:`GooseFEM::Mesh::Stitch::coor`.") .def("conn", &GooseFEM::Mesh::Stitch::conn, "Connectivity of stitched mesh." "See :cpp:func:`GooseFEM::Mesh::Stitch::conn`.") .def("dofs", &GooseFEM::Mesh::Stitch::dofs, "DOF numbers per node." "See :cpp:func:`GooseFEM::Mesh::Stitch::dofs`.") .def("nodemap", py::overload_cast<>( &GooseFEM::Mesh::Stitch::nodemap, py::const_), "Node-map for givall sub-meshes." "See :cpp:func:`GooseFEM::Mesh::Stitch::nodemap`.") .def("elemmap", py::overload_cast<>( &GooseFEM::Mesh::Stitch::elemmap, py::const_), "Element-map for all sub-meshes." "See :cpp:func:`GooseFEM::Mesh::Stitch::elemmap`.") .def("nodemap", py::overload_cast( &GooseFEM::Mesh::Stitch::nodemap, py::const_), "Node-map for given sub-mesh." "See :cpp:func:`GooseFEM::Mesh::Stitch::nodemap`.", py::arg("mesh_index")) .def("elemmap", py::overload_cast( &GooseFEM::Mesh::Stitch::elemmap, py::const_), "Element-map for given sub-mesh." "See :cpp:func:`GooseFEM::Mesh::Stitch::elemmap`.", py::arg("mesh_index")) .def("nodeset", static_cast (GooseFEM::Mesh::Stitch::*)( const xt::xtensor&, size_t) const>(&GooseFEM::Mesh::Stitch::nodeset), "Convert node-set to the stitched mesh." "See :cpp:func:`GooseFEM::Mesh::Stitch::nodeset`.", py::arg("set"), py::arg("mesh_index")) .def("elemset", static_cast (GooseFEM::Mesh::Stitch::*)( const xt::xtensor&, size_t) const>(&GooseFEM::Mesh::Stitch::elemset), "Convert element-set to the stitched mesh." "See :cpp:func:`GooseFEM::Mesh::Stitch::elemset`.", py::arg("set"), py::arg("mesh_index")) .def("nodeset", static_cast (GooseFEM::Mesh::Stitch::*)( const std::vector>&) const>(&GooseFEM::Mesh::Stitch::nodeset), "Convert node-set to the stitched mesh." "See :cpp:func:`GooseFEM::Mesh::Stitch::nodeset`.", py::arg("set")) .def("elemset", static_cast (GooseFEM::Mesh::Stitch::*)( const std::vector>&) const>(&GooseFEM::Mesh::Stitch::elemset), "Convert element-set to the stitched mesh." "See :cpp:func:`GooseFEM::Mesh::Stitch::elemset`.", py::arg("set")) .def("__repr__", [](const GooseFEM::Mesh::Stitch&) { return ""; }); py::class_(m, "Vstack") .def(py::init(), "Vstack meshes." "See :cpp:class:`GooseFEM::Mesh::Vstack`.", py::arg("check_overlap") = true, py::arg("rtol") = 1e-5, py::arg("atol") = 1e-8) .def("push_back", &GooseFEM::Mesh::Vstack::push_back, xt::xtensor, xt::xtensor>, "Add mesh to be stitched." "See :cpp:func:`GooseFEM::Mesh::Vstack::push_back`.", py::arg("coor"), py::arg("conn"), py::arg("nodes_bottom"), py::arg("nodes_top")) .def("__repr__", [](const GooseFEM::Mesh::Vstack&) { return ""; }); py::class_(m, "Renumber") .def(py::init&>(), "Renumber to lowest possible index." "See :cpp:class:`GooseFEM::Mesh::Renumber`.", py::arg("dofs")) .def("get", &GooseFEM::Mesh::Renumber::apply>, "Get renumbered DOFs." "See :cpp:func:`GooseFEM::Mesh::Renumber::get`.") .def("apply", &GooseFEM::Mesh::Renumber::apply>, "Get renumbered list." "See :cpp:func:`GooseFEM::Mesh::Renumber::apply`.") .def("index", &GooseFEM::Mesh::Renumber::index, "Get index list to apply renumbering. Apply renumbering using ``index[dofs]``." "See :cpp:func:`GooseFEM::Mesh::Renumber::index`.") .def("__repr__", [](const GooseFEM::Mesh::Renumber&) { return ""; }); py::class_(m, "Reorder") .def(py::init([](xt::xtensor& a) { return new GooseFEM::Mesh::Reorder({a}); }), "Reorder to lowest possible index." "See :cpp:class:`GooseFEM::Mesh::Reorder`.") .def(py::init([](xt::xtensor& a, xt::xtensor& b) { return new GooseFEM::Mesh::Reorder({a, b}); }), "Reorder to lowest possible index." "See :cpp:class:`GooseFEM::Mesh::Reorder`.") .def(py::init( [](xt::xtensor& a, xt::xtensor& b, xt::xtensor& c) { return new GooseFEM::Mesh::Reorder({a, b, c}); }), "Reorder to lowest possible index." "See :cpp:class:`GooseFEM::Mesh::Reorder`.") .def(py::init([](xt::xtensor& a, xt::xtensor& b, xt::xtensor& c, xt::xtensor& d) { return new GooseFEM::Mesh::Reorder({a, b, c, d}); }), "Reorder to lowest possible index." "See :cpp:class:`GooseFEM::Mesh::Reorder`.") .def("get", &GooseFEM::Mesh::Reorder::apply>, "Reorder matrix (e.g. ``dofs``)." "See :cpp:func:`GooseFEM::Mesh::Reorder::get`.", py::arg("dofs")) .def("apply", &GooseFEM::Mesh::Reorder::apply>, "Get reordered list." "See :cpp:func:`GooseFEM::Mesh::Reorder::apply`.") .def("index", &GooseFEM::Mesh::Reorder::index, "Get index list to apply renumbering. Apply renumbering using ``index[dofs]``." "See :cpp:func:`GooseFEM::Mesh::Reorder::index`.") .def("__repr__", [](const GooseFEM::Mesh::Reorder&) { return ""; }); m.def("dofs", &GooseFEM::Mesh::dofs, "List with DOF-numbers in sequential order." "See :cpp:func:`GooseFEM::Mesh::dofs`.", py::arg("nnode"), py::arg("ndim")); m.def("renumber", &GooseFEM::Mesh::renumber>, "Renumber to lowest possible indices." "See :cpp:func:`GooseFEM::Mesh::renumber`.", py::arg("dofs")); m.def("coordination", &GooseFEM::Mesh::coordination>, "Coordination number of each node." "See :cpp:func:`GooseFEM::Mesh::coordination`.", py::arg("conn")); m.def("elem2node", &GooseFEM::Mesh::elem2node, "Element-numbers connected to each node." "See :cpp:func:`GooseFEM::Mesh::elem2node`.", py::arg("conn"), py::arg("sorted") = true); m.def("edgesize", py::overload_cast&, const xt::xtensor&>( &GooseFEM::Mesh::edgesize), "Get the edge size of all elements." "See :cpp:func:`GooseFEM::Mesh::edgesize`.", py::arg("coor"), py::arg("conn")); m.def("edgesize", py::overload_cast< const xt::xtensor&, const xt::xtensor&, GooseFEM::Mesh::ElementType>(&GooseFEM::Mesh::edgesize), "Get the edge size of all elements." "See :cpp:func:`GooseFEM::Mesh::edgesize`.", py::arg("coor"), py::arg("conn"), py::arg("type")); m.def("centers", py::overload_cast&, const xt::xtensor&>( &GooseFEM::Mesh::centers), "Coordinates of the center of each element." "See :cpp:func:`GooseFEM::Mesh::centers`.", py::arg("coor"), py::arg("conn")); m.def("centers", py::overload_cast< const xt::xtensor&, const xt::xtensor&, GooseFEM::Mesh::ElementType>(&GooseFEM::Mesh::centers), "Coordinates of the center of each element." "See :cpp:func:`GooseFEM::Mesh::centers`.", py::arg("coor"), py::arg("conn"), py::arg("type")); m.def("elemmap2nodemap", py::overload_cast< const xt::xtensor&, const xt::xtensor&, const xt::xtensor&>(&GooseFEM::Mesh::elemmap2nodemap), "Convert an element-map to a node-map." "See :cpp:func:`GooseFEM::Mesh::elemmap2nodemap`.", py::arg("elem_map"), py::arg("coor"), py::arg("conn")); m.def("elemmap2nodemap", py::overload_cast< const xt::xtensor&, const xt::xtensor&, const xt::xtensor&, GooseFEM::Mesh::ElementType>(&GooseFEM::Mesh::elemmap2nodemap), "Convert an element-map to a node-map." "See :cpp:func:`GooseFEM::Mesh::elemmap2nodemap`.", py::arg("elem_map"), py::arg("coor"), py::arg("conn"), py::arg("type")); } diff --git a/python/MeshHex8.hpp b/python/MeshHex8.hpp index 323b0f1..7337bf7 100644 --- a/python/MeshHex8.hpp +++ b/python/MeshHex8.hpp @@ -1,612 +1,614 @@ /* ================================================================================================= (c - GPLv3) T.W.J. de Geus (Tom) | tom@geus.me | www.geus.me | github.com/tdegeus/GooseFEM ================================================================================================= */ #include #include +#include +#include #include namespace py = pybind11; void init_MeshHex8(py::module& m) { py::class_(m, "Regular") .def( py::init(), "Mesh with nx*ny*nz 'pixels' and edge size h", py::arg("nx"), py::arg("ny"), py::arg("nz"), py::arg("h") = 1.) .def("nelem", &GooseFEM::Mesh::Hex8::Regular::nelem) .def("nnode", &GooseFEM::Mesh::Hex8::Regular::nnode) .def("nne", &GooseFEM::Mesh::Hex8::Regular::nne) .def("ndim", &GooseFEM::Mesh::Hex8::Regular::ndim) .def("coor", &GooseFEM::Mesh::Hex8::Regular::coor) .def("conn", &GooseFEM::Mesh::Hex8::Regular::conn) .def("getElementType", &GooseFEM::Mesh::Hex8::Regular::getElementType) .def("nodesFront", &GooseFEM::Mesh::Hex8::Regular::nodesFront) .def("nodesBack", &GooseFEM::Mesh::Hex8::Regular::nodesBack) .def("nodesLeft", &GooseFEM::Mesh::Hex8::Regular::nodesLeft) .def("nodesRight", &GooseFEM::Mesh::Hex8::Regular::nodesRight) .def("nodesBottom", &GooseFEM::Mesh::Hex8::Regular::nodesBottom) .def("nodesTop", &GooseFEM::Mesh::Hex8::Regular::nodesTop) .def("nodesFrontFace", &GooseFEM::Mesh::Hex8::Regular::nodesFrontFace) .def("nodesBackFace", &GooseFEM::Mesh::Hex8::Regular::nodesBackFace) .def("nodesLeftFace", &GooseFEM::Mesh::Hex8::Regular::nodesLeftFace) .def("nodesRightFace", &GooseFEM::Mesh::Hex8::Regular::nodesRightFace) .def("nodesBottomFace", &GooseFEM::Mesh::Hex8::Regular::nodesBottomFace) .def("nodesTopFace", &GooseFEM::Mesh::Hex8::Regular::nodesTopFace) .def("nodesFrontBottomEdge", &GooseFEM::Mesh::Hex8::Regular::nodesFrontBottomEdge) .def("nodesFrontTopEdge", &GooseFEM::Mesh::Hex8::Regular::nodesFrontTopEdge) .def("nodesFrontLeftEdge", &GooseFEM::Mesh::Hex8::Regular::nodesFrontLeftEdge) .def("nodesFrontRightEdge", &GooseFEM::Mesh::Hex8::Regular::nodesFrontRightEdge) .def("nodesBackBottomEdge", &GooseFEM::Mesh::Hex8::Regular::nodesBackBottomEdge) .def("nodesBackTopEdge", &GooseFEM::Mesh::Hex8::Regular::nodesBackTopEdge) .def("nodesBackLeftEdge", &GooseFEM::Mesh::Hex8::Regular::nodesBackLeftEdge) .def("nodesBackRightEdge", &GooseFEM::Mesh::Hex8::Regular::nodesBackRightEdge) .def("nodesBottomLeftEdge", &GooseFEM::Mesh::Hex8::Regular::nodesBottomLeftEdge) .def("nodesBottomRightEdge", &GooseFEM::Mesh::Hex8::Regular::nodesBottomRightEdge) .def("nodesTopLeftEdge", &GooseFEM::Mesh::Hex8::Regular::nodesTopLeftEdge) .def("nodesTopRightEdge", &GooseFEM::Mesh::Hex8::Regular::nodesTopRightEdge) .def("nodesBottomFrontEdge", &GooseFEM::Mesh::Hex8::Regular::nodesBottomFrontEdge) .def("nodesBottomBackEdge", &GooseFEM::Mesh::Hex8::Regular::nodesBottomBackEdge) .def("nodesTopFrontEdge", &GooseFEM::Mesh::Hex8::Regular::nodesTopFrontEdge) .def("nodesTopBackEdge", &GooseFEM::Mesh::Hex8::Regular::nodesTopBackEdge) .def("nodesLeftBottomEdge", &GooseFEM::Mesh::Hex8::Regular::nodesLeftBottomEdge) .def("nodesLeftFrontEdge", &GooseFEM::Mesh::Hex8::Regular::nodesLeftFrontEdge) .def("nodesLeftBackEdge", &GooseFEM::Mesh::Hex8::Regular::nodesLeftBackEdge) .def("nodesLeftTopEdge", &GooseFEM::Mesh::Hex8::Regular::nodesLeftTopEdge) .def("nodesRightBottomEdge", &GooseFEM::Mesh::Hex8::Regular::nodesRightBottomEdge) .def("nodesRightTopEdge", &GooseFEM::Mesh::Hex8::Regular::nodesRightTopEdge) .def("nodesRightFrontEdge", &GooseFEM::Mesh::Hex8::Regular::nodesRightFrontEdge) .def("nodesRightBackEdge", &GooseFEM::Mesh::Hex8::Regular::nodesRightBackEdge) .def("nodesFrontBottomOpenEdge", &GooseFEM::Mesh::Hex8::Regular::nodesFrontBottomOpenEdge) .def("nodesFrontTopOpenEdge", &GooseFEM::Mesh::Hex8::Regular::nodesFrontTopOpenEdge) .def("nodesFrontLeftOpenEdge", &GooseFEM::Mesh::Hex8::Regular::nodesFrontLeftOpenEdge) .def("nodesFrontRightOpenEdge", &GooseFEM::Mesh::Hex8::Regular::nodesFrontRightOpenEdge) .def("nodesBackBottomOpenEdge", &GooseFEM::Mesh::Hex8::Regular::nodesBackBottomOpenEdge) .def("nodesBackTopOpenEdge", &GooseFEM::Mesh::Hex8::Regular::nodesBackTopOpenEdge) .def("nodesBackLeftOpenEdge", &GooseFEM::Mesh::Hex8::Regular::nodesBackLeftOpenEdge) .def("nodesBackRightOpenEdge", &GooseFEM::Mesh::Hex8::Regular::nodesBackRightOpenEdge) .def("nodesBottomLeftOpenEdge", &GooseFEM::Mesh::Hex8::Regular::nodesBottomLeftOpenEdge) .def("nodesBottomRightOpenEdge", &GooseFEM::Mesh::Hex8::Regular::nodesBottomRightOpenEdge) .def("nodesTopLeftOpenEdge", &GooseFEM::Mesh::Hex8::Regular::nodesTopLeftOpenEdge) .def("nodesTopRightOpenEdge", &GooseFEM::Mesh::Hex8::Regular::nodesTopRightOpenEdge) .def("nodesBottomFrontOpenEdge", &GooseFEM::Mesh::Hex8::Regular::nodesBottomFrontOpenEdge) .def("nodesBottomBackOpenEdge", &GooseFEM::Mesh::Hex8::Regular::nodesBottomBackOpenEdge) .def("nodesTopFrontOpenEdge", &GooseFEM::Mesh::Hex8::Regular::nodesTopFrontOpenEdge) .def("nodesTopBackOpenEdge", &GooseFEM::Mesh::Hex8::Regular::nodesTopBackOpenEdge) .def("nodesLeftBottomOpenEdge", &GooseFEM::Mesh::Hex8::Regular::nodesLeftBottomOpenEdge) .def("nodesLeftFrontOpenEdge", &GooseFEM::Mesh::Hex8::Regular::nodesLeftFrontOpenEdge) .def("nodesLeftBackOpenEdge", &GooseFEM::Mesh::Hex8::Regular::nodesLeftBackOpenEdge) .def("nodesLeftTopOpenEdge", &GooseFEM::Mesh::Hex8::Regular::nodesLeftTopOpenEdge) .def("nodesRightBottomOpenEdge", &GooseFEM::Mesh::Hex8::Regular::nodesRightBottomOpenEdge) .def("nodesRightTopOpenEdge", &GooseFEM::Mesh::Hex8::Regular::nodesRightTopOpenEdge) .def("nodesRightFrontOpenEdge", &GooseFEM::Mesh::Hex8::Regular::nodesRightFrontOpenEdge) .def("nodesRightBackOpenEdge", &GooseFEM::Mesh::Hex8::Regular::nodesRightBackOpenEdge) .def( "nodesFrontBottomLeftCorner", &GooseFEM::Mesh::Hex8::Regular::nodesFrontBottomLeftCorner) .def( "nodesFrontBottomRightCorner", &GooseFEM::Mesh::Hex8::Regular::nodesFrontBottomRightCorner) .def("nodesFrontTopLeftCorner", &GooseFEM::Mesh::Hex8::Regular::nodesFrontTopLeftCorner) .def("nodesFrontTopRightCorner", &GooseFEM::Mesh::Hex8::Regular::nodesFrontTopRightCorner) .def("nodesBackBottomLeftCorner", &GooseFEM::Mesh::Hex8::Regular::nodesBackBottomLeftCorner) .def( "nodesBackBottomRightCorner", &GooseFEM::Mesh::Hex8::Regular::nodesBackBottomRightCorner) .def("nodesBackTopLeftCorner", &GooseFEM::Mesh::Hex8::Regular::nodesBackTopLeftCorner) .def("nodesBackTopRightCorner", &GooseFEM::Mesh::Hex8::Regular::nodesBackTopRightCorner) .def( "nodesFrontLeftBottomCorner", &GooseFEM::Mesh::Hex8::Regular::nodesFrontLeftBottomCorner) .def( "nodesBottomFrontLeftCorner", &GooseFEM::Mesh::Hex8::Regular::nodesBottomFrontLeftCorner) .def( "nodesBottomLeftFrontCorner", &GooseFEM::Mesh::Hex8::Regular::nodesBottomLeftFrontCorner) .def( "nodesLeftFrontBottomCorner", &GooseFEM::Mesh::Hex8::Regular::nodesLeftFrontBottomCorner) .def( "nodesLeftBottomFrontCorner", &GooseFEM::Mesh::Hex8::Regular::nodesLeftBottomFrontCorner) .def( "nodesFrontRightBottomCorner", &GooseFEM::Mesh::Hex8::Regular::nodesFrontRightBottomCorner) .def( "nodesBottomFrontRightCorner", &GooseFEM::Mesh::Hex8::Regular::nodesBottomFrontRightCorner) .def( "nodesBottomRightFrontCorner", &GooseFEM::Mesh::Hex8::Regular::nodesBottomRightFrontCorner) .def( "nodesRightFrontBottomCorner", &GooseFEM::Mesh::Hex8::Regular::nodesRightFrontBottomCorner) .def( "nodesRightBottomFrontCorner", &GooseFEM::Mesh::Hex8::Regular::nodesRightBottomFrontCorner) .def("nodesFrontLeftTopCorner", &GooseFEM::Mesh::Hex8::Regular::nodesFrontLeftTopCorner) .def("nodesTopFrontLeftCorner", &GooseFEM::Mesh::Hex8::Regular::nodesTopFrontLeftCorner) .def("nodesTopLeftFrontCorner", &GooseFEM::Mesh::Hex8::Regular::nodesTopLeftFrontCorner) .def("nodesLeftFrontTopCorner", &GooseFEM::Mesh::Hex8::Regular::nodesLeftFrontTopCorner) .def("nodesLeftTopFrontCorner", &GooseFEM::Mesh::Hex8::Regular::nodesLeftTopFrontCorner) .def("nodesFrontRightTopCorner", &GooseFEM::Mesh::Hex8::Regular::nodesFrontRightTopCorner) .def("nodesTopFrontRightCorner", &GooseFEM::Mesh::Hex8::Regular::nodesTopFrontRightCorner) .def("nodesTopRightFrontCorner", &GooseFEM::Mesh::Hex8::Regular::nodesTopRightFrontCorner) .def("nodesRightFrontTopCorner", &GooseFEM::Mesh::Hex8::Regular::nodesRightFrontTopCorner) .def("nodesRightTopFrontCorner", &GooseFEM::Mesh::Hex8::Regular::nodesRightTopFrontCorner) .def("nodesBackLeftBottomCorner", &GooseFEM::Mesh::Hex8::Regular::nodesBackLeftBottomCorner) .def("nodesBottomBackLeftCorner", &GooseFEM::Mesh::Hex8::Regular::nodesBottomBackLeftCorner) .def("nodesBottomLeftBackCorner", &GooseFEM::Mesh::Hex8::Regular::nodesBottomLeftBackCorner) .def("nodesLeftBackBottomCorner", &GooseFEM::Mesh::Hex8::Regular::nodesLeftBackBottomCorner) .def("nodesLeftBottomBackCorner", &GooseFEM::Mesh::Hex8::Regular::nodesLeftBottomBackCorner) .def( "nodesBackRightBottomCorner", &GooseFEM::Mesh::Hex8::Regular::nodesBackRightBottomCorner) .def( "nodesBottomBackRightCorner", &GooseFEM::Mesh::Hex8::Regular::nodesBottomBackRightCorner) .def( "nodesBottomRightBackCorner", &GooseFEM::Mesh::Hex8::Regular::nodesBottomRightBackCorner) .def( "nodesRightBackBottomCorner", &GooseFEM::Mesh::Hex8::Regular::nodesRightBackBottomCorner) .def( "nodesRightBottomBackCorner", &GooseFEM::Mesh::Hex8::Regular::nodesRightBottomBackCorner) .def("nodesBackLeftTopCorner", &GooseFEM::Mesh::Hex8::Regular::nodesBackLeftTopCorner) .def("nodesTopBackLeftCorner", &GooseFEM::Mesh::Hex8::Regular::nodesTopBackLeftCorner) .def("nodesTopLeftBackCorner", &GooseFEM::Mesh::Hex8::Regular::nodesTopLeftBackCorner) .def("nodesLeftBackTopCorner", &GooseFEM::Mesh::Hex8::Regular::nodesLeftBackTopCorner) .def("nodesLeftTopBackCorner", &GooseFEM::Mesh::Hex8::Regular::nodesLeftTopBackCorner) .def("nodesBackRightTopCorner", &GooseFEM::Mesh::Hex8::Regular::nodesBackRightTopCorner) .def("nodesTopBackRightCorner", &GooseFEM::Mesh::Hex8::Regular::nodesTopBackRightCorner) .def("nodesTopRightBackCorner", &GooseFEM::Mesh::Hex8::Regular::nodesTopRightBackCorner) .def("nodesRightBackTopCorner", &GooseFEM::Mesh::Hex8::Regular::nodesRightBackTopCorner) .def("nodesRightTopBackCorner", &GooseFEM::Mesh::Hex8::Regular::nodesRightTopBackCorner) .def("nodesPeriodic", &GooseFEM::Mesh::Hex8::Regular::nodesPeriodic) .def("nodesOrigin", &GooseFEM::Mesh::Hex8::Regular::nodesOrigin) .def("dofs", &GooseFEM::Mesh::Hex8::Regular::dofs) .def("dofsPeriodic", &GooseFEM::Mesh::Hex8::Regular::dofsPeriodic) .def("__repr__", [](const GooseFEM::Mesh::Hex8::Regular&) { return ""; }); py::class_(m, "FineLayer") .def( py::init(), "Mesh with nx*ny*nz 'pixels' and edge size h", py::arg("nx"), py::arg("ny"), py::arg("nz"), py::arg("h") = 1.0, py::arg("nfine") = 1) .def("nelem", &GooseFEM::Mesh::Hex8::FineLayer::nelem) .def("nnode", &GooseFEM::Mesh::Hex8::FineLayer::nnode) .def("nne", &GooseFEM::Mesh::Hex8::FineLayer::nne) .def("ndim", &GooseFEM::Mesh::Hex8::FineLayer::ndim) .def("nelx", &GooseFEM::Mesh::Hex8::FineLayer::nelx) .def("nely", &GooseFEM::Mesh::Hex8::FineLayer::nely) .def("nelz", &GooseFEM::Mesh::Hex8::FineLayer::nelz) .def("coor", &GooseFEM::Mesh::Hex8::FineLayer::coor) .def("conn", &GooseFEM::Mesh::Hex8::FineLayer::conn) .def("getElementType", &GooseFEM::Mesh::Hex8::FineLayer::getElementType) .def("elementsMiddleLayer", &GooseFEM::Mesh::Hex8::FineLayer::elementsMiddleLayer) .def("nodesFront", &GooseFEM::Mesh::Hex8::FineLayer::nodesFront) .def("nodesBack", &GooseFEM::Mesh::Hex8::FineLayer::nodesBack) .def("nodesLeft", &GooseFEM::Mesh::Hex8::FineLayer::nodesLeft) .def("nodesRight", &GooseFEM::Mesh::Hex8::FineLayer::nodesRight) .def("nodesBottom", &GooseFEM::Mesh::Hex8::FineLayer::nodesBottom) .def("nodesTop", &GooseFEM::Mesh::Hex8::FineLayer::nodesTop) .def("nodesFrontFace", &GooseFEM::Mesh::Hex8::FineLayer::nodesFrontFace) .def("nodesBackFace", &GooseFEM::Mesh::Hex8::FineLayer::nodesBackFace) .def("nodesLeftFace", &GooseFEM::Mesh::Hex8::FineLayer::nodesLeftFace) .def("nodesRightFace", &GooseFEM::Mesh::Hex8::FineLayer::nodesRightFace) .def("nodesBottomFace", &GooseFEM::Mesh::Hex8::FineLayer::nodesBottomFace) .def("nodesTopFace", &GooseFEM::Mesh::Hex8::FineLayer::nodesTopFace) .def("nodesFrontBottomEdge", &GooseFEM::Mesh::Hex8::FineLayer::nodesFrontBottomEdge) .def("nodesFrontTopEdge", &GooseFEM::Mesh::Hex8::FineLayer::nodesFrontTopEdge) .def("nodesFrontLeftEdge", &GooseFEM::Mesh::Hex8::FineLayer::nodesFrontLeftEdge) .def("nodesFrontRightEdge", &GooseFEM::Mesh::Hex8::FineLayer::nodesFrontRightEdge) .def("nodesBackBottomEdge", &GooseFEM::Mesh::Hex8::FineLayer::nodesBackBottomEdge) .def("nodesBackTopEdge", &GooseFEM::Mesh::Hex8::FineLayer::nodesBackTopEdge) .def("nodesBackLeftEdge", &GooseFEM::Mesh::Hex8::FineLayer::nodesBackLeftEdge) .def("nodesBackRightEdge", &GooseFEM::Mesh::Hex8::FineLayer::nodesBackRightEdge) .def("nodesBottomLeftEdge", &GooseFEM::Mesh::Hex8::FineLayer::nodesBottomLeftEdge) .def("nodesBottomRightEdge", &GooseFEM::Mesh::Hex8::FineLayer::nodesBottomRightEdge) .def("nodesTopLeftEdge", &GooseFEM::Mesh::Hex8::FineLayer::nodesTopLeftEdge) .def("nodesTopRightEdge", &GooseFEM::Mesh::Hex8::FineLayer::nodesTopRightEdge) .def("nodesBottomFrontEdge", &GooseFEM::Mesh::Hex8::FineLayer::nodesBottomFrontEdge) .def("nodesBottomBackEdge", &GooseFEM::Mesh::Hex8::FineLayer::nodesBottomBackEdge) .def("nodesTopFrontEdge", &GooseFEM::Mesh::Hex8::FineLayer::nodesTopFrontEdge) .def("nodesTopBackEdge", &GooseFEM::Mesh::Hex8::FineLayer::nodesTopBackEdge) .def("nodesLeftBottomEdge", &GooseFEM::Mesh::Hex8::FineLayer::nodesLeftBottomEdge) .def("nodesLeftFrontEdge", &GooseFEM::Mesh::Hex8::FineLayer::nodesLeftFrontEdge) .def("nodesLeftBackEdge", &GooseFEM::Mesh::Hex8::FineLayer::nodesLeftBackEdge) .def("nodesLeftTopEdge", &GooseFEM::Mesh::Hex8::FineLayer::nodesLeftTopEdge) .def("nodesRightBottomEdge", &GooseFEM::Mesh::Hex8::FineLayer::nodesRightBottomEdge) .def("nodesRightTopEdge", &GooseFEM::Mesh::Hex8::FineLayer::nodesRightTopEdge) .def("nodesRightFrontEdge", &GooseFEM::Mesh::Hex8::FineLayer::nodesRightFrontEdge) .def("nodesRightBackEdge", &GooseFEM::Mesh::Hex8::FineLayer::nodesRightBackEdge) .def("nodesFrontBottomOpenEdge", &GooseFEM::Mesh::Hex8::FineLayer::nodesFrontBottomOpenEdge) .def("nodesFrontTopOpenEdge", &GooseFEM::Mesh::Hex8::FineLayer::nodesFrontTopOpenEdge) .def("nodesFrontLeftOpenEdge", &GooseFEM::Mesh::Hex8::FineLayer::nodesFrontLeftOpenEdge) .def("nodesFrontRightOpenEdge", &GooseFEM::Mesh::Hex8::FineLayer::nodesFrontRightOpenEdge) .def("nodesBackBottomOpenEdge", &GooseFEM::Mesh::Hex8::FineLayer::nodesBackBottomOpenEdge) .def("nodesBackTopOpenEdge", &GooseFEM::Mesh::Hex8::FineLayer::nodesBackTopOpenEdge) .def("nodesBackLeftOpenEdge", &GooseFEM::Mesh::Hex8::FineLayer::nodesBackLeftOpenEdge) .def("nodesBackRightOpenEdge", &GooseFEM::Mesh::Hex8::FineLayer::nodesBackRightOpenEdge) .def("nodesBottomLeftOpenEdge", &GooseFEM::Mesh::Hex8::FineLayer::nodesBottomLeftOpenEdge) .def("nodesBottomRightOpenEdge", &GooseFEM::Mesh::Hex8::FineLayer::nodesBottomRightOpenEdge) .def("nodesTopLeftOpenEdge", &GooseFEM::Mesh::Hex8::FineLayer::nodesTopLeftOpenEdge) .def("nodesTopRightOpenEdge", &GooseFEM::Mesh::Hex8::FineLayer::nodesTopRightOpenEdge) .def("nodesBottomFrontOpenEdge", &GooseFEM::Mesh::Hex8::FineLayer::nodesBottomFrontOpenEdge) .def("nodesBottomBackOpenEdge", &GooseFEM::Mesh::Hex8::FineLayer::nodesBottomBackOpenEdge) .def("nodesTopFrontOpenEdge", &GooseFEM::Mesh::Hex8::FineLayer::nodesTopFrontOpenEdge) .def("nodesTopBackOpenEdge", &GooseFEM::Mesh::Hex8::FineLayer::nodesTopBackOpenEdge) .def("nodesLeftBottomOpenEdge", &GooseFEM::Mesh::Hex8::FineLayer::nodesLeftBottomOpenEdge) .def("nodesLeftFrontOpenEdge", &GooseFEM::Mesh::Hex8::FineLayer::nodesLeftFrontOpenEdge) .def("nodesLeftBackOpenEdge", &GooseFEM::Mesh::Hex8::FineLayer::nodesLeftBackOpenEdge) .def("nodesLeftTopOpenEdge", &GooseFEM::Mesh::Hex8::FineLayer::nodesLeftTopOpenEdge) .def("nodesRightBottomOpenEdge", &GooseFEM::Mesh::Hex8::FineLayer::nodesRightBottomOpenEdge) .def("nodesRightTopOpenEdge", &GooseFEM::Mesh::Hex8::FineLayer::nodesRightTopOpenEdge) .def("nodesRightFrontOpenEdge", &GooseFEM::Mesh::Hex8::FineLayer::nodesRightFrontOpenEdge) .def("nodesRightBackOpenEdge", &GooseFEM::Mesh::Hex8::FineLayer::nodesRightBackOpenEdge) .def( "nodesFrontBottomLeftCorner", &GooseFEM::Mesh::Hex8::FineLayer::nodesFrontBottomLeftCorner) .def( "nodesFrontBottomRightCorner", &GooseFEM::Mesh::Hex8::FineLayer::nodesFrontBottomRightCorner) .def("nodesFrontTopLeftCorner", &GooseFEM::Mesh::Hex8::FineLayer::nodesFrontTopLeftCorner) .def("nodesFrontTopRightCorner", &GooseFEM::Mesh::Hex8::FineLayer::nodesFrontTopRightCorner) .def( "nodesBackBottomLeftCorner", &GooseFEM::Mesh::Hex8::FineLayer::nodesBackBottomLeftCorner) .def( "nodesBackBottomRightCorner", &GooseFEM::Mesh::Hex8::FineLayer::nodesBackBottomRightCorner) .def("nodesBackTopLeftCorner", &GooseFEM::Mesh::Hex8::FineLayer::nodesBackTopLeftCorner) .def("nodesBackTopRightCorner", &GooseFEM::Mesh::Hex8::FineLayer::nodesBackTopRightCorner) .def( "nodesFrontLeftBottomCorner", &GooseFEM::Mesh::Hex8::FineLayer::nodesFrontLeftBottomCorner) .def( "nodesBottomFrontLeftCorner", &GooseFEM::Mesh::Hex8::FineLayer::nodesBottomFrontLeftCorner) .def( "nodesBottomLeftFrontCorner", &GooseFEM::Mesh::Hex8::FineLayer::nodesBottomLeftFrontCorner) .def( "nodesLeftFrontBottomCorner", &GooseFEM::Mesh::Hex8::FineLayer::nodesLeftFrontBottomCorner) .def( "nodesLeftBottomFrontCorner", &GooseFEM::Mesh::Hex8::FineLayer::nodesLeftBottomFrontCorner) .def( "nodesFrontRightBottomCorner", &GooseFEM::Mesh::Hex8::FineLayer::nodesFrontRightBottomCorner) .def( "nodesBottomFrontRightCorner", &GooseFEM::Mesh::Hex8::FineLayer::nodesBottomFrontRightCorner) .def( "nodesBottomRightFrontCorner", &GooseFEM::Mesh::Hex8::FineLayer::nodesBottomRightFrontCorner) .def( "nodesRightFrontBottomCorner", &GooseFEM::Mesh::Hex8::FineLayer::nodesRightFrontBottomCorner) .def( "nodesRightBottomFrontCorner", &GooseFEM::Mesh::Hex8::FineLayer::nodesRightBottomFrontCorner) .def("nodesFrontLeftTopCorner", &GooseFEM::Mesh::Hex8::FineLayer::nodesFrontLeftTopCorner) .def("nodesTopFrontLeftCorner", &GooseFEM::Mesh::Hex8::FineLayer::nodesTopFrontLeftCorner) .def("nodesTopLeftFrontCorner", &GooseFEM::Mesh::Hex8::FineLayer::nodesTopLeftFrontCorner) .def("nodesLeftFrontTopCorner", &GooseFEM::Mesh::Hex8::FineLayer::nodesLeftFrontTopCorner) .def("nodesLeftTopFrontCorner", &GooseFEM::Mesh::Hex8::FineLayer::nodesLeftTopFrontCorner) .def("nodesFrontRightTopCorner", &GooseFEM::Mesh::Hex8::FineLayer::nodesFrontRightTopCorner) .def("nodesTopFrontRightCorner", &GooseFEM::Mesh::Hex8::FineLayer::nodesTopFrontRightCorner) .def("nodesTopRightFrontCorner", &GooseFEM::Mesh::Hex8::FineLayer::nodesTopRightFrontCorner) .def("nodesRightFrontTopCorner", &GooseFEM::Mesh::Hex8::FineLayer::nodesRightFrontTopCorner) .def("nodesRightTopFrontCorner", &GooseFEM::Mesh::Hex8::FineLayer::nodesRightTopFrontCorner) .def( "nodesBackLeftBottomCorner", &GooseFEM::Mesh::Hex8::FineLayer::nodesBackLeftBottomCorner) .def( "nodesBottomBackLeftCorner", &GooseFEM::Mesh::Hex8::FineLayer::nodesBottomBackLeftCorner) .def( "nodesBottomLeftBackCorner", &GooseFEM::Mesh::Hex8::FineLayer::nodesBottomLeftBackCorner) .def( "nodesLeftBackBottomCorner", &GooseFEM::Mesh::Hex8::FineLayer::nodesLeftBackBottomCorner) .def( "nodesLeftBottomBackCorner", &GooseFEM::Mesh::Hex8::FineLayer::nodesLeftBottomBackCorner) .def( "nodesBackRightBottomCorner", &GooseFEM::Mesh::Hex8::FineLayer::nodesBackRightBottomCorner) .def( "nodesBottomBackRightCorner", &GooseFEM::Mesh::Hex8::FineLayer::nodesBottomBackRightCorner) .def( "nodesBottomRightBackCorner", &GooseFEM::Mesh::Hex8::FineLayer::nodesBottomRightBackCorner) .def( "nodesRightBackBottomCorner", &GooseFEM::Mesh::Hex8::FineLayer::nodesRightBackBottomCorner) .def( "nodesRightBottomBackCorner", &GooseFEM::Mesh::Hex8::FineLayer::nodesRightBottomBackCorner) .def("nodesBackLeftTopCorner", &GooseFEM::Mesh::Hex8::FineLayer::nodesBackLeftTopCorner) .def("nodesTopBackLeftCorner", &GooseFEM::Mesh::Hex8::FineLayer::nodesTopBackLeftCorner) .def("nodesTopLeftBackCorner", &GooseFEM::Mesh::Hex8::FineLayer::nodesTopLeftBackCorner) .def("nodesLeftBackTopCorner", &GooseFEM::Mesh::Hex8::FineLayer::nodesLeftBackTopCorner) .def("nodesLeftTopBackCorner", &GooseFEM::Mesh::Hex8::FineLayer::nodesLeftTopBackCorner) .def("nodesBackRightTopCorner", &GooseFEM::Mesh::Hex8::FineLayer::nodesBackRightTopCorner) .def("nodesTopBackRightCorner", &GooseFEM::Mesh::Hex8::FineLayer::nodesTopBackRightCorner) .def("nodesTopRightBackCorner", &GooseFEM::Mesh::Hex8::FineLayer::nodesTopRightBackCorner) .def("nodesRightBackTopCorner", &GooseFEM::Mesh::Hex8::FineLayer::nodesRightBackTopCorner) .def("nodesRightTopBackCorner", &GooseFEM::Mesh::Hex8::FineLayer::nodesRightTopBackCorner) .def("nodesPeriodic", &GooseFEM::Mesh::Hex8::FineLayer::nodesPeriodic) .def("nodesOrigin", &GooseFEM::Mesh::Hex8::FineLayer::nodesOrigin) .def("dofs", &GooseFEM::Mesh::Hex8::FineLayer::dofs) .def("dofsPeriodic", &GooseFEM::Mesh::Hex8::FineLayer::dofsPeriodic) .def("__repr__", [](const GooseFEM::Mesh::Hex8::FineLayer&) { return ""; }); } diff --git a/python/MeshQuad4.hpp b/python/MeshQuad4.hpp index 1f13fdd..2f0892a 100644 --- a/python/MeshQuad4.hpp +++ b/python/MeshQuad4.hpp @@ -1,248 +1,250 @@ /* ================================================================================================= (c - GPLv3) T.W.J. de Geus (Tom) | tom@geus.me | www.geus.me | github.com/tdegeus/GooseFEM ================================================================================================= */ #include #include #include +#include +#include #include namespace py = pybind11; void init_MeshQuad4(py::module& m) { py::class_(m, "Regular") .def( py::init(), "Regular mesh: 'nx' pixels in horizontal direction, 'ny' in vertical direction, edge " "size 'h'", py::arg("nx"), py::arg("ny"), py::arg("h") = 1.) .def("coor", &GooseFEM::Mesh::Quad4::Regular::coor) .def("conn", &GooseFEM::Mesh::Quad4::Regular::conn) .def("nelem", &GooseFEM::Mesh::Quad4::Regular::nelem) .def("nnode", &GooseFEM::Mesh::Quad4::Regular::nnode) .def("nne", &GooseFEM::Mesh::Quad4::Regular::nne) .def("ndim", &GooseFEM::Mesh::Quad4::Regular::ndim) .def("nelx", &GooseFEM::Mesh::Quad4::Regular::nelx) .def("nely", &GooseFEM::Mesh::Quad4::Regular::nely) .def("h", &GooseFEM::Mesh::Quad4::Regular::h) .def("getElementType", &GooseFEM::Mesh::Quad4::Regular::getElementType) .def("nodesBottomEdge", &GooseFEM::Mesh::Quad4::Regular::nodesBottomEdge) .def("nodesTopEdge", &GooseFEM::Mesh::Quad4::Regular::nodesTopEdge) .def("nodesLeftEdge", &GooseFEM::Mesh::Quad4::Regular::nodesLeftEdge) .def("nodesRightEdge", &GooseFEM::Mesh::Quad4::Regular::nodesRightEdge) .def("nodesBottomOpenEdge", &GooseFEM::Mesh::Quad4::Regular::nodesBottomOpenEdge) .def("nodesTopOpenEdge", &GooseFEM::Mesh::Quad4::Regular::nodesTopOpenEdge) .def("nodesLeftOpenEdge", &GooseFEM::Mesh::Quad4::Regular::nodesLeftOpenEdge) .def("nodesRightOpenEdge", &GooseFEM::Mesh::Quad4::Regular::nodesRightOpenEdge) .def("nodesBottomLeftCorner", &GooseFEM::Mesh::Quad4::Regular::nodesBottomLeftCorner) .def("nodesBottomRightCorner", &GooseFEM::Mesh::Quad4::Regular::nodesBottomRightCorner) .def("nodesTopLeftCorner", &GooseFEM::Mesh::Quad4::Regular::nodesTopLeftCorner) .def("nodesTopRightCorner", &GooseFEM::Mesh::Quad4::Regular::nodesTopRightCorner) .def("nodesLeftBottomCorner", &GooseFEM::Mesh::Quad4::Regular::nodesLeftBottomCorner) .def("nodesLeftTopCorner", &GooseFEM::Mesh::Quad4::Regular::nodesLeftTopCorner) .def("nodesRightBottomCorner", &GooseFEM::Mesh::Quad4::Regular::nodesRightBottomCorner) .def("nodesRightTopCorner", &GooseFEM::Mesh::Quad4::Regular::nodesRightTopCorner) .def("dofs", &GooseFEM::Mesh::Quad4::Regular::dofs) .def("nodesPeriodic", &GooseFEM::Mesh::Quad4::Regular::nodesPeriodic) .def("nodesOrigin", &GooseFEM::Mesh::Quad4::Regular::nodesOrigin) .def("dofsPeriodic", &GooseFEM::Mesh::Quad4::Regular::dofsPeriodic) .def("elementgrid", &GooseFEM::Mesh::Quad4::Regular::elementgrid) .def("__repr__", [](const GooseFEM::Mesh::Quad4::Regular&) { return ""; }); py::class_(m, "FineLayer") .def( py::init(), "FineLayer mesh: 'nx' pixels in horizontal direction (length 'Lx'), idem in vertical " "direction", py::arg("nx"), py::arg("ny"), py::arg("h") = 1., py::arg("nfine") = 1) .def( py::init&, const xt::xtensor&>(), "Map connectivity to generating FineLayer-object.", py::arg("coor"), py::arg("conn")) .def("coor", &GooseFEM::Mesh::Quad4::FineLayer::coor) .def("conn", &GooseFEM::Mesh::Quad4::FineLayer::conn) .def("nelem", &GooseFEM::Mesh::Quad4::FineLayer::nelem) .def("nnode", &GooseFEM::Mesh::Quad4::FineLayer::nnode) .def("nne", &GooseFEM::Mesh::Quad4::FineLayer::nne) .def("ndim", &GooseFEM::Mesh::Quad4::FineLayer::ndim) .def("nelx", &GooseFEM::Mesh::Quad4::FineLayer::nelx) .def("nely", &GooseFEM::Mesh::Quad4::FineLayer::nely) .def("h", &GooseFEM::Mesh::Quad4::FineLayer::h) .def("elemrow_nhx", &GooseFEM::Mesh::Quad4::FineLayer::elemrow_nhx) .def("elemrow_nhy", &GooseFEM::Mesh::Quad4::FineLayer::elemrow_nhy) .def("elemrow_nelem", &GooseFEM::Mesh::Quad4::FineLayer::elemrow_nelem) .def("getElementType", &GooseFEM::Mesh::Quad4::FineLayer::getElementType) .def("elementsMiddleLayer", &GooseFEM::Mesh::Quad4::FineLayer::elementsMiddleLayer) .def("elementsLayer", &GooseFEM::Mesh::Quad4::FineLayer::elementsLayer) .def( "elementgrid_ravel", &GooseFEM::Mesh::Quad4::FineLayer::elementgrid_ravel, py::arg("rows_range"), py::arg("cols_range")) .def( "elementgrid_around_ravel", &GooseFEM::Mesh::Quad4::FineLayer::elementgrid_around_ravel, py::arg("element"), py::arg("size"), py::arg("periodic") = true) .def( "elementgrid_leftright", &GooseFEM::Mesh::Quad4::FineLayer::elementgrid_leftright, py::arg("element"), py::arg("left"), py::arg("right"), py::arg("periodic") = true) .def("nodesBottomEdge", &GooseFEM::Mesh::Quad4::FineLayer::nodesBottomEdge) .def("nodesTopEdge", &GooseFEM::Mesh::Quad4::FineLayer::nodesTopEdge) .def("nodesLeftEdge", &GooseFEM::Mesh::Quad4::FineLayer::nodesLeftEdge) .def("nodesRightEdge", &GooseFEM::Mesh::Quad4::FineLayer::nodesRightEdge) .def("nodesBottomOpenEdge", &GooseFEM::Mesh::Quad4::FineLayer::nodesBottomOpenEdge) .def("nodesTopOpenEdge", &GooseFEM::Mesh::Quad4::FineLayer::nodesTopOpenEdge) .def("nodesLeftOpenEdge", &GooseFEM::Mesh::Quad4::FineLayer::nodesLeftOpenEdge) .def("nodesRightOpenEdge", &GooseFEM::Mesh::Quad4::FineLayer::nodesRightOpenEdge) .def("nodesBottomLeftCorner", &GooseFEM::Mesh::Quad4::FineLayer::nodesBottomLeftCorner) .def("nodesBottomRightCorner", &GooseFEM::Mesh::Quad4::FineLayer::nodesBottomRightCorner) .def("nodesTopLeftCorner", &GooseFEM::Mesh::Quad4::FineLayer::nodesTopLeftCorner) .def("nodesTopRightCorner", &GooseFEM::Mesh::Quad4::FineLayer::nodesTopRightCorner) .def("nodesLeftBottomCorner", &GooseFEM::Mesh::Quad4::FineLayer::nodesLeftBottomCorner) .def("nodesLeftTopCorner", &GooseFEM::Mesh::Quad4::FineLayer::nodesLeftTopCorner) .def("nodesRightBottomCorner", &GooseFEM::Mesh::Quad4::FineLayer::nodesRightBottomCorner) .def("nodesRightTopCorner", &GooseFEM::Mesh::Quad4::FineLayer::nodesRightTopCorner) .def("dofs", &GooseFEM::Mesh::Quad4::FineLayer::dofs) .def("nodesPeriodic", &GooseFEM::Mesh::Quad4::FineLayer::nodesPeriodic) .def("nodesOrigin", &GooseFEM::Mesh::Quad4::FineLayer::nodesOrigin) .def("dofsPeriodic", &GooseFEM::Mesh::Quad4::FineLayer::dofsPeriodic) .def("roll", &GooseFEM::Mesh::Quad4::FineLayer::roll) .def("__repr__", [](const GooseFEM::Mesh::Quad4::FineLayer&) { return ""; }); } void init_MeshQuad4Map(py::module& m) { py::class_(m, "RefineRegular") .def( py::init(), "Refine a regular mesh", py::arg("mesh"), py::arg("nx"), py::arg("ny")) .def("getCoarseMesh", &GooseFEM::Mesh::Quad4::Map::RefineRegular::getCoarseMesh) .def("getFineMesh", &GooseFEM::Mesh::Quad4::Map::RefineRegular::getFineMesh) .def("getMap", &GooseFEM::Mesh::Quad4::Map::RefineRegular::getMap) .def("meanToCoarse", py::overload_cast&>( &GooseFEM::Mesh::Quad4::Map::RefineRegular::meanToCoarse, py::const_)) .def("meanToCoarse", py::overload_cast&>( &GooseFEM::Mesh::Quad4::Map::RefineRegular::meanToCoarse, py::const_)) .def("meanToCoarse", py::overload_cast&>( &GooseFEM::Mesh::Quad4::Map::RefineRegular::meanToCoarse, py::const_)) .def("meanToCoarse", py::overload_cast&>( &GooseFEM::Mesh::Quad4::Map::RefineRegular::meanToCoarse, py::const_)) .def("averageToCoarse", py::overload_cast&, const xt::xtensor&>( &GooseFEM::Mesh::Quad4::Map::RefineRegular::averageToCoarse, py::const_)) .def("averageToCoarse", py::overload_cast&, const xt::xtensor&>( &GooseFEM::Mesh::Quad4::Map::RefineRegular::averageToCoarse, py::const_)) .def("averageToCoarse", py::overload_cast&, const xt::xtensor&>( &GooseFEM::Mesh::Quad4::Map::RefineRegular::averageToCoarse, py::const_)) .def("averageToCoarse", py::overload_cast&, const xt::xtensor&>( &GooseFEM::Mesh::Quad4::Map::RefineRegular::averageToCoarse, py::const_)) .def("mapToFine", py::overload_cast&>( &GooseFEM::Mesh::Quad4::Map::RefineRegular::mapToFine, py::const_)) .def("mapToFine", py::overload_cast&>( &GooseFEM::Mesh::Quad4::Map::RefineRegular::mapToFine, py::const_)) .def("mapToFine", py::overload_cast&>( &GooseFEM::Mesh::Quad4::Map::RefineRegular::mapToFine, py::const_)) .def("mapToFine", py::overload_cast&>( &GooseFEM::Mesh::Quad4::Map::RefineRegular::mapToFine, py::const_)) .def("__repr__", [](const GooseFEM::Mesh::Quad4::Map::RefineRegular&) { return ""; }); py::class_(m, "FineLayer2Regular") .def( py::init(), "Map a FineLayer mesh to a Regular mesh", py::arg("mesh")) .def("getRegularMesh", &GooseFEM::Mesh::Quad4::Map::FineLayer2Regular::getRegularMesh) .def("getFineLayerMesh", &GooseFEM::Mesh::Quad4::Map::FineLayer2Regular::getFineLayerMesh) .def("getMap", &GooseFEM::Mesh::Quad4::Map::FineLayer2Regular::getMap) .def("getMapFraction", &GooseFEM::Mesh::Quad4::Map::FineLayer2Regular::getMapFraction) .def("mapToRegular", py::overload_cast&>( &GooseFEM::Mesh::Quad4::Map::FineLayer2Regular::mapToRegular, py::const_)) .def("mapToRegular", py::overload_cast&>( &GooseFEM::Mesh::Quad4::Map::FineLayer2Regular::mapToRegular, py::const_)) .def("mapToRegular", py::overload_cast&>( &GooseFEM::Mesh::Quad4::Map::FineLayer2Regular::mapToRegular, py::const_)) .def("mapToRegular", py::overload_cast&>( &GooseFEM::Mesh::Quad4::Map::FineLayer2Regular::mapToRegular, py::const_)) .def("__repr__", [](const GooseFEM::Mesh::Quad4::Map::FineLayer2Regular&) { return ""; }); } diff --git a/python/MeshTri3.hpp b/python/MeshTri3.hpp index 79a33f1..b58213c 100644 --- a/python/MeshTri3.hpp +++ b/python/MeshTri3.hpp @@ -1,112 +1,114 @@ /* ================================================================================================= (c - GPLv3) T.W.J. de Geus (Tom) | tom@geus.me | www.geus.me | github.com/tdegeus/GooseFEM ================================================================================================= */ #include #include +#include +#include #include namespace py = pybind11; void init_MeshTri3(py::module& m) { py::class_(m, "Regular") .def( py::init(), "Regular mesh: 'nx' pixels in horizontal direction, 'ny' in vertical direction, edge " "size 'h'", py::arg("nx"), py::arg("ny"), py::arg("h") = 1.) .def("coor", &GooseFEM::Mesh::Tri3::Regular::coor) .def("conn", &GooseFEM::Mesh::Tri3::Regular::conn) .def("nelem", &GooseFEM::Mesh::Tri3::Regular::nelem) .def("nnode", &GooseFEM::Mesh::Tri3::Regular::nnode) .def("nne", &GooseFEM::Mesh::Tri3::Regular::nne) .def("ndim", &GooseFEM::Mesh::Tri3::Regular::ndim) .def("getElementType", &GooseFEM::Mesh::Tri3::Regular::getElementType) .def("nodesBottomEdge", &GooseFEM::Mesh::Tri3::Regular::nodesBottomEdge) .def("nodesTopEdge", &GooseFEM::Mesh::Tri3::Regular::nodesTopEdge) .def("nodesLeftEdge", &GooseFEM::Mesh::Tri3::Regular::nodesLeftEdge) .def("nodesRightEdge", &GooseFEM::Mesh::Tri3::Regular::nodesRightEdge) .def("nodesBottomOpenEdge", &GooseFEM::Mesh::Tri3::Regular::nodesBottomOpenEdge) .def("nodesTopOpenEdge", &GooseFEM::Mesh::Tri3::Regular::nodesTopOpenEdge) .def("nodesLeftOpenEdge", &GooseFEM::Mesh::Tri3::Regular::nodesLeftOpenEdge) .def("nodesRightOpenEdge", &GooseFEM::Mesh::Tri3::Regular::nodesRightOpenEdge) .def("nodesBottomLeftCorner", &GooseFEM::Mesh::Tri3::Regular::nodesBottomLeftCorner) .def("nodesBottomRightCorner", &GooseFEM::Mesh::Tri3::Regular::nodesBottomRightCorner) .def("nodesTopLeftCorner", &GooseFEM::Mesh::Tri3::Regular::nodesTopLeftCorner) .def("nodesTopRightCorner", &GooseFEM::Mesh::Tri3::Regular::nodesTopRightCorner) .def("nodesLeftBottomCorner", &GooseFEM::Mesh::Tri3::Regular::nodesLeftBottomCorner) .def("nodesLeftTopCorner", &GooseFEM::Mesh::Tri3::Regular::nodesLeftTopCorner) .def("nodesRightBottomCorner", &GooseFEM::Mesh::Tri3::Regular::nodesRightBottomCorner) .def("nodesRightTopCorner", &GooseFEM::Mesh::Tri3::Regular::nodesRightTopCorner) .def("nodesPeriodic", &GooseFEM::Mesh::Tri3::Regular::nodesPeriodic) .def("nodesOrigin", &GooseFEM::Mesh::Tri3::Regular::nodesOrigin) .def("dofs", &GooseFEM::Mesh::Tri3::Regular::dofs) .def("dofsPeriodic", &GooseFEM::Mesh::Tri3::Regular::dofsPeriodic) .def("__repr__", [](const GooseFEM::Mesh::Tri3::Regular&) { return ""; }); m.def( "getOrientation", &GooseFEM::Mesh::Tri3::getOrientation, "Get the orientation of each element", py::arg("coor"), py::arg("conn")); m.def( "setOrientation", py::overload_cast&, const xt::xtensor&, int>( &GooseFEM::Mesh::Tri3::setOrientation), "Set the orientation of each element", py::arg("coor"), py::arg("conn"), py::arg("orientation")); m.def( "setOrientation", py::overload_cast< const xt::xtensor&, const xt::xtensor&, const xt::xtensor&, int>(&GooseFEM::Mesh::Tri3::setOrientation), "Set the orientation of each element", py::arg("coor"), py::arg("conn"), py::arg("val"), py::arg("orientation")); } diff --git a/python/Vector.hpp b/python/Vector.hpp index 4f78cd2..2b08e38 100644 --- a/python/Vector.hpp +++ b/python/Vector.hpp @@ -1,91 +1,93 @@ /* ================================================================================================= (c - GPLv3) T.W.J. de Geus (Tom) | tom@geus.me | www.geus.me | github.com/tdegeus/GooseFEM ================================================================================================= */ #include #include +#include +#include #include namespace py = pybind11; void init_Vector(py::module& m) { py::class_(m, "Vector") .def(py::init&, const xt::pytensor&>(), "Switch between dofval/nodevec/elemvec", py::arg("conn"), py::arg("dofs")) .def("nelem", &GooseFEM::Vector::nelem, "Number of element") .def("nne", &GooseFEM::Vector::nne, "Number of nodes per element") .def("nnode", &GooseFEM::Vector::nnode, "Number of nodes") .def("ndim", &GooseFEM::Vector::ndim, "Number of dimensions") .def("ndof", &GooseFEM::Vector::ndof, "Number of degrees-of-freedom") .def("conn", &GooseFEM::Vector::conn, "Return connectivity") .def("dofs", &GooseFEM::Vector::dofs, "Return degrees-of-freedom") .def("Copy", &GooseFEM::Vector::Copy>, py::arg("nodevec_src"), py::arg("nodevec_dest")) .def("AsDofs", &GooseFEM::Vector::AsDofs>, "Convert to 'dofval' (overwrite entries that occur more than once", py::arg("arg")) .def("AsNode", &GooseFEM::Vector::AsNode>, "Convert to 'nodevec' (overwrite entries that occur more than once", py::arg("arg")) .def("AsElement", &GooseFEM::Vector::AsElement>, "Convert to 'elemvec' (overwrite entries that occur more than once", py::arg("arg")) .def("AssembleDofs", &GooseFEM::Vector::AssembleDofs>, "Assemble to 'dofval' (add entries that occur more than once", py::arg("arg")) .def("AssembleNode", &GooseFEM::Vector::AssembleNode>, "Assemble to 'nodevec' (add entries that occur more than once", py::arg("arg")) .def("shape_dofval", &GooseFEM::Vector::shape_dofval) .def("shape_nodevec", &GooseFEM::Vector::shape_nodevec) .def("shape_elemvec", &GooseFEM::Vector::shape_elemvec) .def("shape_elemmat", &GooseFEM::Vector::shape_elemmat) .def("allocate_dofval", py::overload_cast<>(&GooseFEM::Vector::allocate_dofval, py::const_)) .def("allocate_dofval", py::overload_cast(&GooseFEM::Vector::allocate_dofval, py::const_)) .def("allocate_nodevec", py::overload_cast<>(&GooseFEM::Vector::allocate_nodevec, py::const_)) .def("allocate_nodevec", py::overload_cast(&GooseFEM::Vector::allocate_nodevec, py::const_)) .def("allocate_elemvec", py::overload_cast<>(&GooseFEM::Vector::allocate_elemvec, py::const_)) .def("allocate_elemvec", py::overload_cast(&GooseFEM::Vector::allocate_elemvec, py::const_)) .def("allocate_elemmat", py::overload_cast<>(&GooseFEM::Vector::allocate_elemmat, py::const_)) .def("allocate_elemmat", py::overload_cast(&GooseFEM::Vector::allocate_elemmat, py::const_)) .def("__repr__", [](const GooseFEM::Vector&) { return ""; }); } diff --git a/python/VectorPartitioned.hpp b/python/VectorPartitioned.hpp index 9c6a962..375cf77 100644 --- a/python/VectorPartitioned.hpp +++ b/python/VectorPartitioned.hpp @@ -1,105 +1,107 @@ /* ================================================================================================= (c - GPLv3) T.W.J. de Geus (Tom) | tom@geus.me | www.geus.me | github.com/tdegeus/GooseFEM ================================================================================================= */ #include #include +#include +#include #include namespace py = pybind11; void init_VectorPartitioned(py::module& m) { py::class_(m, "VectorPartitioned") .def( py::init< const xt::xtensor&, const xt::xtensor&, const xt::xtensor&>(), "Switch between dofval/nodevec/elemvec", py::arg("conn"), py::arg("dofs"), py::arg("iip")) .def("nnu", &GooseFEM::VectorPartitioned::nnu, "Number of unknown degrees-of-freedom") .def("nnp", &GooseFEM::VectorPartitioned::nnp, "Number of prescribed degrees-of-freedom") .def("iiu", &GooseFEM::VectorPartitioned::iiu, "Return unknown degrees-of-freedom") .def("iip", &GooseFEM::VectorPartitioned::iip, "Return prescribed degrees-of-freedom") .def("dofs_is_u", &GooseFEM::VectorPartitioned::dofs_is_u, "Per DOF list if unknown." "See :cpp:class:`GooseFEM::VectorPartitioned::dofs_is_u`.") .def("dofs_is_p", &GooseFEM::VectorPartitioned::dofs_is_p, "Per DOF list if unknown." "See :cpp:class:`GooseFEM::VectorPartitioned::dofs_is_p`.") .def( "DofsFromParitioned", py::overload_cast&, const xt::xtensor&>( &GooseFEM::VectorPartitioned::DofsFromParitioned, py::const_), "Set 'dofval", py::arg("dofval_u"), py::arg("dofval_p")) .def( "AsDofs_u", py::overload_cast&>( &GooseFEM::VectorPartitioned::AsDofs_u, py::const_), "Set 'dofval", py::arg("nodevec")) .def( "AsDofs_u", py::overload_cast&>( &GooseFEM::VectorPartitioned::AsDofs_u, py::const_), "Set 'dofval", py::arg("elemvec")) .def( "AsDofs_p", py::overload_cast&>( &GooseFEM::VectorPartitioned::AsDofs_p, py::const_), "Set 'dofval", py::arg("nodevec")) .def( "AsDofs_p", py::overload_cast&>( &GooseFEM::VectorPartitioned::AsDofs_p, py::const_), "Set 'dofval", py::arg("elemvec")) .def( "NodeFromPartitioned", py::overload_cast&, const xt::xtensor&>( &GooseFEM::VectorPartitioned::NodeFromPartitioned, py::const_), "Set 'nodevec", py::arg("dofval_u"), py::arg("dofval_p")) .def( "ElementFromPartitioned", py::overload_cast&, const xt::xtensor&>( &GooseFEM::VectorPartitioned::ElementFromPartitioned, py::const_), "Set 'elemvec", py::arg("dofval_u"), py::arg("dofval_p")) .def("Copy_u", &GooseFEM::VectorPartitioned::Copy_u, "Copy iiu") .def("Copy_p", &GooseFEM::VectorPartitioned::Copy_p, "Copy iip") .def("__repr__", [](const GooseFEM::VectorPartitioned&) { return ""; }); } diff --git a/python/VectorPartitionedTyings.hpp b/python/VectorPartitionedTyings.hpp index a41fbce..814b727 100644 --- a/python/VectorPartitionedTyings.hpp +++ b/python/VectorPartitionedTyings.hpp @@ -1,57 +1,59 @@ /* ================================================================================================= (c - GPLv3) T.W.J. de Geus (Tom) | tom@geus.me | www.geus.me | github.com/tdegeus/GooseFEM ================================================================================================= */ #include #include +#include +#include #include namespace py = pybind11; void init_VectorPartitionedTyings(py::module& m) { py::class_(m, "VectorPartitionedTyings") .def( py::init< const xt::xtensor&, const xt::xtensor&, const Eigen::SparseMatrix&, const Eigen::SparseMatrix&, const Eigen::SparseMatrix&>(), "Switch between dofval/nodevec/elemvec", py::arg("conn"), py::arg("dofs"), py::arg("Cdu"), py::arg("Cdp"), py::arg("Cdi")) .def("nnu", &GooseFEM::VectorPartitionedTyings::nnu, "Number of unknown DOFs") .def("nnp", &GooseFEM::VectorPartitionedTyings::nnp, "Number of prescribed DOFs") .def("nni", &GooseFEM::VectorPartitionedTyings::nni, "Number of independent DOFs") .def("nnd", &GooseFEM::VectorPartitionedTyings::nnd, "Number of dependent DOFs") .def("iiu", &GooseFEM::VectorPartitionedTyings::iiu, "Unknown DOFs") .def("iip", &GooseFEM::VectorPartitionedTyings::iip, "Prescribed DOFs") .def("iii", &GooseFEM::VectorPartitionedTyings::iii, "Independent DOFs") .def("iid", &GooseFEM::VectorPartitionedTyings::iid, "Dependent DOFs") .def( "AsDofs_i", &GooseFEM::VectorPartitionedTyings::AsDofs_i, "Set 'dofval", py::arg("nodevec")) .def("__repr__", [](const GooseFEM::VectorPartitionedTyings&) { return ""; }); } diff --git a/python/main.cpp b/python/main.cpp index 740e628..20f9473 100644 --- a/python/main.cpp +++ b/python/main.cpp @@ -1,137 +1,137 @@ /* ================================================================================================= (c - GPLv3) T.W.J. de Geus (Tom) | tom@geus.me | www.geus.me | github.com/tdegeus/GooseFEM ================================================================================================= */ -#include - #include #include #include #define FORCE_IMPORT_ARRAY #include #include +#include + +#include #define GOOSEFEM_ENABLE_ASSERT #define GOOSEFEM_ENABLE_WARNING_PYTHON -#include namespace py = pybind11; #include "version.hpp" #include "Allocate.hpp" #include "Vector.hpp" #include "VectorPartitioned.hpp" #include "VectorPartitionedTyings.hpp" #include "Matrix.hpp" #include "MatrixPartitioned.hpp" #include "MatrixPartitionedTyings.hpp" #include "MatrixDiagonal.hpp" #include "MatrixDiagonalPartitioned.hpp" #include "Element.hpp" #include "ElementQuad4.hpp" #include "ElementQuad4Planar.hpp" #include "ElementQuad4Axisymmetric.hpp" #include "ElementHex8.hpp" #include "Mesh.hpp" #include "MeshTri3.hpp" #include "MeshQuad4.hpp" #include "MeshHex8.hpp" PYBIND11_MODULE(GooseFEM, m) { xt::import_numpy(); // -------- // GooseFEM // -------- m.doc() = "Some simple finite element meshes and operations"; init_version(m); init_Allocate(m); init_Vector(m); init_VectorPartitioned(m); init_VectorPartitionedTyings(m); init_Matrix(m); init_MatrixPartitioned(m); init_MatrixPartitionedTyings(m); init_MatrixDiagonal(m); init_MatrixDiagonalPartitioned(m); // ---------------- // GooseFEM.Element // ---------------- py::module mElement = m.def_submodule("Element", "Generic element routines"); init_Element(mElement); // ---------------------- // GooseFEM.Element.Quad4 // ---------------------- py::module mElementQuad4 = mElement.def_submodule("Quad4", "Linear quadrilateral elements (2D)"); py::module mElementQuad4Gauss = mElementQuad4.def_submodule("Gauss", "Gauss quadrature"); py::module mElementQuad4Nodal = mElementQuad4.def_submodule("Nodal", "Nodal quadrature"); py::module mElementQuad4MidPoint = mElementQuad4.def_submodule("MidPoint", "MidPoint quadrature"); init_ElementQuad4(mElementQuad4); init_ElementQuad4Planar(mElementQuad4); init_ElementQuad4Axisymmetric(mElementQuad4); init_ElementQuad4Gauss(mElementQuad4Gauss); init_ElementQuad4Nodal(mElementQuad4Nodal); init_ElementQuad4MidPoint(mElementQuad4MidPoint); // --------------------- // GooseFEM.Element.Hex8 // --------------------- py::module mElementHex8 = mElement.def_submodule("Hex8", "Linear hexahedron (brick) elements (3D)"); py::module mElementHex8Gauss = mElementHex8.def_submodule("Gauss", "Gauss quadrature"); py::module mElementHex8Nodal = mElementHex8.def_submodule("Nodal", "Nodal quadrature"); init_ElementHex8(mElementHex8); init_ElementHex8Gauss(mElementHex8Gauss); init_ElementHex8Nodal(mElementHex8Nodal); // ------------- // GooseFEM.Mesh // ------------- py::module mMesh = m.def_submodule("Mesh", "Generic mesh routines"); init_Mesh(mMesh); // ------------------ // GooseFEM.Mesh.Tri3 // ------------------ py::module mMeshTri3 = mMesh.def_submodule("Tri3", "Linear triangular elements (2D)"); init_MeshTri3(mMeshTri3); // ------------------- // GooseFEM.Mesh.Quad4 // ------------------- py::module mMeshQuad4 = mMesh.def_submodule("Quad4", "Linear quadrilateral elements (2D)"); init_MeshQuad4(mMeshQuad4); py::module mMeshQuad4Map = mMeshQuad4.def_submodule("Map", "Map mesh objects"); init_MeshQuad4Map(mMeshQuad4Map); // ------------------ // GooseFEM.Mesh.Hex8 // ------------------ py::module mMeshHex8 = mMesh.def_submodule("Hex8", "Linear hexahedron (brick) elements (3D)"); init_MeshHex8(mMeshHex8); } diff --git a/python/version.hpp b/python/version.hpp index 8f87871..e05602b 100644 --- a/python/version.hpp +++ b/python/version.hpp @@ -1,28 +1,25 @@ /* ================================================================================================= (c - GPLv3) T.W.J. de Geus (Tom) | tom@geus.me | www.geus.me | github.com/tdegeus/GooseFEM ================================================================================================= */ -#include -#include -#include #include -#include +#include namespace py = pybind11; void init_version(py::module& m) { m.def("version", &GooseFEM::version, "Return version string." "See :cpp:class:`GooseFEM::version`."); m.def("version_dependencies", &GooseFEM::version_dependencies, "Return version information of library and its dependencies." "See :cpp:class:`GooseFEM::version_dependencies`."); }