diff --git a/include/xGooseFEM/Vector.h b/include/xGooseFEM/Vector.h index 1b2168e..8849f94 100644 --- a/include/xGooseFEM/Vector.h +++ b/include/xGooseFEM/Vector.h @@ -1,191 +1,192 @@ /* ================================================================================================= (c - GPLv3) T.W.J. de Geus (Tom) | tom@geus.me | www.geus.me | github.com/tdegeus/GooseFEM ================================================================================================= */ #ifndef XGOOSEFEM_VECTOR_H #define XGOOSEFEM_VECTOR_H // ------------------------------------------------------------------------------------------------- #include "GooseFEM.h" // =========================================== GooseFEM ============================================ namespace xGooseFEM { // ------------------------------------------------------------------------------------------------- /* "nodevec" - nodal vectors - [nnode, ndim] "elemvec" - nodal vectors stored per element - [nelem, nne, ndim] "dofval" - DOF values - [ndof] "dofval_u" - DOF values (Unknown) "== dofval[iiu]" - [nnu] "dofval_p" - DOF values (Prescribed) "== dofval[iiu]" - [nnp] */ class Vector { public: // constructor Vector() = default; Vector(const xt::xtensor &conn, const xt::xtensor &dofs); Vector(const xt::xtensor &conn, const xt::xtensor &dofs, const xt::xtensor &iip); // dimensions size_t nelem() const; // number of elements size_t nne() const; // number of nodes per element size_t nnode() const; // number of nodes size_t ndim() const; // number of dimensions size_t ndof() const; // number of DOFs size_t nnu() const; // number of unknown DOFs size_t nnp() const; // number of prescribed DOFs // DOF lists xt::xtensor dofs() const; // DOFs xt::xtensor iiu() const; // unknown DOFs xt::xtensor iip() const; // prescribed DOFs // convert to "dofval" (overwrite entries that occur more than once) -- (auto allocation below) void asDofs (const xt::xtensor &dofval_u, const xt::xtensor &dofval_p, xt::xtensor &dofval) const; void asDofs (const xt::xtensor &nodevec, xt::xtensor &dofval) const; void asDofs (const xt::xtensor &elemvec, xt::xtensor &dofval) const; void asDofs_u(const xt::xtensor &nodevec, xt::xtensor &dofval_u) const; void asDofs_u(const xt::xtensor &elemvec, xt::xtensor &dofval_u) const; void asDofs_p(const xt::xtensor &nodevec, xt::xtensor &dofval_p) const; void asDofs_p(const xt::xtensor &elemvec, xt::xtensor &dofval_p) const; // convert to "nodevec" (overwrite entries that occur more than once) -- (auto allocation below) - void asNode(const xt::xtensor &dofval, + void asNode(const xt::xtensor &dofval_u, const xt::xtensor &dofval_p, xt::xtensor &nodevec) const; - void asNode(const xt::xtensor &dofval_u, const xt::xtensor &dofval_p, + void asNode(const xt::xtensor &dofval, xt::xtensor &nodevec) const; + void asNode(const xt::xtensor &elemvec, xt::xtensor &nodevec) const; // convert to "elemvec" (overwrite entries that occur more than once) -- (auto allocation below) - void asElement(const xt::xtensor &dofval, + void asElement(const xt::xtensor &dofval_u, const xt::xtensor &dofval_p, xt::xtensor &elemvec) const; - void asElement(const xt::xtensor &dofval_u, const xt::xtensor &dofval_p, + void asElement(const xt::xtensor &dofval, xt::xtensor &elemvec) const; void asElement(const xt::xtensor &nodevec, xt::xtensor &elemvec) const; // convert to "dofval" (overwrite entries that occur more than once) xt::xtensor asDofs (const xt::xtensor &dofval_u, const xt::xtensor &dofval_p) const; xt::xtensor asDofs (const xt::xtensor &nodevec) const; xt::xtensor asDofs (const xt::xtensor &elemvec) const; xt::xtensor asDofs_u(const xt::xtensor &nodevec) const; xt::xtensor asDofs_u(const xt::xtensor &elemvec) const; xt::xtensor asDofs_p(const xt::xtensor &nodevec) const; xt::xtensor asDofs_p(const xt::xtensor &elemvec) const; // convert to "nodevec" (overwrite entries that occur more than once) xt::xtensor asNode(const xt::xtensor &dofval_u, const xt::xtensor &dofval_p) const; xt::xtensor asNode(const xt::xtensor &dofval) const; xt::xtensor asNode(const xt::xtensor &elemvec) const; // convert to "elemvec" (overwrite entries that occur more than once) xt::xtensor asElement(const xt::xtensor &dofval_u, const xt::xtensor &dofval_p) const; xt::xtensor asElement(const xt::xtensor &dofval) const; xt::xtensor asElement(const xt::xtensor &nodevec) const; // assemble "dofval" (adds entries that occur more that once) -- (auto allocation below) void assembleDofs (const xt::xtensor &nodevec, xt::xtensor &dofval ) const; void assembleDofs (const xt::xtensor &elemvec, xt::xtensor &dofval ) const; void assembleDofs_u(const xt::xtensor &nodevec, xt::xtensor &dofval_u) const; void assembleDofs_u(const xt::xtensor &elemvec, xt::xtensor &dofval_u) const; void assembleDofs_p(const xt::xtensor &nodevec, xt::xtensor &dofval_p) const; void assembleDofs_p(const xt::xtensor &elemvec, xt::xtensor &dofval_p) const; // assemble "nodevec" (adds entries that occur more that once) -- (auto allocation below) void assembleNode(const xt::xtensor &elemvec, xt::xtensor &nodevec) const; // assemble "dofval" (adds entries that occur more that once) xt::xtensor assembleDofs (const xt::xtensor &nodevec) const; xt::xtensor assembleDofs (const xt::xtensor &elemvec) const; xt::xtensor assembleDofs_u(const xt::xtensor &nodevec) const; xt::xtensor assembleDofs_u(const xt::xtensor &elemvec) const; xt::xtensor assembleDofs_p(const xt::xtensor &nodevec) const; xt::xtensor assembleDofs_p(const xt::xtensor &elemvec) const; // assemble "nodevec" (adds entries that occur more that once) xt::xtensor assembleNode(const xt::xtensor &elemvec) const; private: // bookkeeping xt::xtensor m_conn; // connectivity [nelem, nne ] xt::xtensor m_dofs; // DOF-numbers per node [nnode, ndim] xt::xtensor m_iiu; // DOF-numbers that are unknown [nnu] xt::xtensor m_iip; // DOF-numbers that are prescribed [nnp] // DOFs per node, such that iiu = arange(nnu), iip = nnu + arange(nnp) xt::xtensor m_part; // dimensions size_t m_nelem; // number of elements size_t m_nne; // number of nodes per element size_t m_nnode; // number of nodes size_t m_ndim; // number of dimensions size_t m_ndof; // number of DOFs size_t m_nnu; // number of unknown DOFs size_t m_nnp; // number of prescribed DOFs }; // ------------------------------------------------------------------------------------------------- } // namespace ... // ================================================================================================= #endif diff --git a/include/xGooseFEM/python.cpp b/include/xGooseFEM/python.cpp index a243859..20fb0c5 100644 --- a/include/xGooseFEM/python.cpp +++ b/include/xGooseFEM/python.cpp @@ -1,941 +1,761 @@ /* ================================================================================================= (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 "GooseFEM.h" // ================================================================================================= -// abbreviate name-space namespace py = pybind11; -namespace M = GooseFEM; +namespace M = xGooseFEM; -// ================================================================================================= +// ======================================= trampoline class ======================================== -class PyGeometry : public GooseFEM::Dynamics::Geometry +class PyGeometry : public xGooseFEM::Dynamics::Geometry { public: - // inherit the constructors - using GooseFEM::Dynamics::Geometry::Geometry; + using xGooseFEM::Dynamics::Geometry::Geometry; using Arr1 = xt::xtensor; using Arr2 = xt::xtensor; using Arr3 = xt::xtensor; - // trampoline - xt::xtensor solve_A() override { PYBIND11_OVERLOAD_PURE( Arr1, GooseFEM::Dynamics::Geometry, solve_A ); } - xt::xtensor solve_V() override { PYBIND11_OVERLOAD_PURE( Arr1, GooseFEM::Dynamics::Geometry, solve_V ); } - xt::xtensor u() const override { PYBIND11_OVERLOAD_PURE( Arr2, GooseFEM::Dynamics::Geometry, u ); } - xt::xtensor v() const override { PYBIND11_OVERLOAD_PURE( Arr2, GooseFEM::Dynamics::Geometry, v ); } - xt::xtensor a() const override { PYBIND11_OVERLOAD_PURE( Arr2, GooseFEM::Dynamics::Geometry, a ); } - xt::xtensor dofs_u() const override { PYBIND11_OVERLOAD_PURE( Arr1, GooseFEM::Dynamics::Geometry, dofs_u ); } - xt::xtensor dofs_v() const override { PYBIND11_OVERLOAD_PURE( Arr1, GooseFEM::Dynamics::Geometry, dofs_v ); } - xt::xtensor dofs_a() const override { PYBIND11_OVERLOAD_PURE( Arr1, GooseFEM::Dynamics::Geometry, dofs_a ); } - void set_u(const xt::xtensor &nodevec) override { PYBIND11_OVERLOAD_PURE( void, GooseFEM::Dynamics::Geometry, set_u , nodevec); } - void set_u(const xt::xtensor &dofval ) override { PYBIND11_OVERLOAD_PURE( void, GooseFEM::Dynamics::Geometry, set_u , dofval ); } - void set_v(const xt::xtensor &dofval ) override { PYBIND11_OVERLOAD_PURE( void, GooseFEM::Dynamics::Geometry, set_v , dofval ); } - void set_a(const xt::xtensor &dofval ) override { PYBIND11_OVERLOAD_PURE( void, GooseFEM::Dynamics::Geometry, set_a , dofval ); } + xt::xtensor solve_A() override { PYBIND11_OVERLOAD_PURE( Arr1, xGooseFEM::Dynamics::Geometry, solve_A ); } + xt::xtensor solve_V() override { PYBIND11_OVERLOAD_PURE( Arr1, xGooseFEM::Dynamics::Geometry, solve_V ); } + xt::xtensor u() const override { PYBIND11_OVERLOAD_PURE( Arr2, xGooseFEM::Dynamics::Geometry, u ); } + xt::xtensor v() const override { PYBIND11_OVERLOAD_PURE( Arr2, xGooseFEM::Dynamics::Geometry, v ); } + xt::xtensor a() const override { PYBIND11_OVERLOAD_PURE( Arr2, xGooseFEM::Dynamics::Geometry, a ); } + xt::xtensor dofs_u() const override { PYBIND11_OVERLOAD_PURE( Arr1, xGooseFEM::Dynamics::Geometry, dofs_u ); } + xt::xtensor dofs_v() const override { PYBIND11_OVERLOAD_PURE( Arr1, xGooseFEM::Dynamics::Geometry, dofs_v ); } + xt::xtensor dofs_a() const override { PYBIND11_OVERLOAD_PURE( Arr1, xGooseFEM::Dynamics::Geometry, dofs_a ); } + + void set_u(const xt::xtensor &nodevec) override { PYBIND11_OVERLOAD_PURE( void, xGooseFEM::Dynamics::Geometry, set_u , nodevec); } + void set_u(const xt::xtensor &dofval ) override { PYBIND11_OVERLOAD_PURE( void, xGooseFEM::Dynamics::Geometry, set_u , dofval ); } + void set_v(const xt::xtensor &dofval ) override { PYBIND11_OVERLOAD_PURE( void, xGooseFEM::Dynamics::Geometry, set_v , dofval ); } + void set_a(const xt::xtensor &dofval ) override { PYBIND11_OVERLOAD_PURE( void, xGooseFEM::Dynamics::Geometry, set_a , dofval ); } }; // =========================================== GooseFEM ============================================ -PYBIND11_MODULE(GooseFEM, m) { +PYBIND11_MODULE(xGooseFEM, m) { m.doc() = "Some simple finite element meshes and operations"; // ======================================== GooseFEM.Vector ======================================== -py::class_(m, "Vector") - // - - .def( - py::init &, const xt::xtensor &>(), - "Class to switch between DOF/nodal/element views of vectors", - py::arg("conn"), - py::arg("dofs") - ) - // - - .def( - py::init &, const xt::xtensor &, const xt::xtensor &>(), - "Class to switch between DOF/nodal/element views of vectors", - py::arg("conn"), - py::arg("dofs"), - py::arg("iip") - ) - // - - .def("nelem", &M::Vector::nelem) - .def("nne" , &M::Vector::nne ) - .def("nnode", &M::Vector::nnode) - .def("ndim" , &M::Vector::ndim ) - .def("ndof" , &M::Vector::ndof ) - .def("nnu" , &M::Vector::nnu ) - .def("nnp" , &M::Vector::nnp ) - // - - .def("dofs" , &M::Vector::dofs ) - .def("iiu" , &M::Vector::iiu ) - .def("iip" , &M::Vector::iip ) - // - - .def("asDofs" , py::overload_cast&,const xt::xtensor&>(&M::Vector::asDofs , py::const_)) - .def("asDofs" , py::overload_cast& >(&M::Vector::asDofs , py::const_)) - .def("asDofs" , py::overload_cast& >(&M::Vector::asDofs , py::const_)) - .def("asDofs_u", py::overload_cast& >(&M::Vector::asDofs_u, py::const_)) - .def("asDofs_u", py::overload_cast& >(&M::Vector::asDofs_u, py::const_)) - .def("asDofs_p", py::overload_cast& >(&M::Vector::asDofs_p, py::const_)) - .def("asDofs_p", py::overload_cast& >(&M::Vector::asDofs_p, py::const_)) - // - - .def("asNode", py::overload_cast& >(&M::Vector::asNode, py::const_)) - .def("asNode", py::overload_cast&,const xt::xtensor&>(&M::Vector::asNode, py::const_)) - .def("asNode", py::overload_cast& >(&M::Vector::asNode, py::const_)) - // - - .def("asElement", py::overload_cast& >(&M::Vector::asElement, py::const_)) - .def("asElement", py::overload_cast&,const xt::xtensor&>(&M::Vector::asElement, py::const_)) - .def("asElement", py::overload_cast& >(&M::Vector::asElement, py::const_)) - // - - .def("assembleDofs" , py::overload_cast&>(&M::Vector::assembleDofs , py::const_)) - .def("assembleDofs" , py::overload_cast&>(&M::Vector::assembleDofs , py::const_)) - .def("assembleDofs_u", py::overload_cast&>(&M::Vector::assembleDofs_u, py::const_)) - .def("assembleDofs_u", py::overload_cast&>(&M::Vector::assembleDofs_u, py::const_)) - .def("assembleDofs_p", py::overload_cast&>(&M::Vector::assembleDofs_p, py::const_)) - .def("assembleDofs_p", py::overload_cast&>(&M::Vector::assembleDofs_p, py::const_)) - // - - .def("assembleNode" , py::overload_cast&>(&M::Vector::assembleNode , py::const_)) - // - - .def("__repr__", - [](const GooseFEM::Vector &){ return ""; } - ); +py::class_(m, "Vector") + + .def(py::init &, const xt::xtensor & >(), "Switch between dofval/nodevec/elemvec", py::arg("conn"), py::arg("dofs")) + .def(py::init &, const xt::xtensor &, const xt::xtensor &>(), "Switch between dofval/nodevec/elemvec", py::arg("conn"), py::arg("dofs"), py::arg("iip")) + + .def("nelem", &M::Vector::nelem, "Return number of element") + .def("nne" , &M::Vector::nne , "Return number of nodes per element") + .def("nnode", &M::Vector::nnode, "Return number of nodes") + .def("ndim" , &M::Vector::ndim , "Return number of dimensions") + .def("ndof" , &M::Vector::ndof , "Return number of degrees-of-freedom") + .def("nnu" , &M::Vector::nnu , "Return number of unknown degrees-of-freedom") + .def("nnp" , &M::Vector::nnp , "Return number of prescribed degrees-of-freedom") + + .def("dofs" , &M::Vector::dofs , "Return degrees-of-freedom") + .def("iiu" , &M::Vector::iiu , "Return unknown degrees-of-freedom") + .def("iip" , &M::Vector::iip , "Return prescribed degrees-of-freedom") + + .def("asDofs" , py::overload_cast&,const xt::xtensor&>(&M::Vector::asDofs , py::const_), "Set 'dofval" , py::arg("dofval_u"), py::arg("dofval_p")) + .def("asDofs" , py::overload_cast& >(&M::Vector::asDofs , py::const_), "Set 'dofval" , py::arg("nodevec")) + .def("asDofs" , py::overload_cast& >(&M::Vector::asDofs , py::const_), "Set 'dofval" , py::arg("elemvec")) + .def("asDofs_u" , py::overload_cast& >(&M::Vector::asDofs_u , py::const_), "Set 'dofval" , py::arg("nodevec")) + .def("asDofs_u" , py::overload_cast& >(&M::Vector::asDofs_u , py::const_), "Set 'dofval" , py::arg("elemvec")) + .def("asDofs_p" , py::overload_cast& >(&M::Vector::asDofs_p , py::const_), "Set 'dofval" , py::arg("nodevec")) + .def("asDofs_p" , py::overload_cast& >(&M::Vector::asDofs_p , py::const_), "Set 'dofval" , py::arg("elemvec")) + + .def("asNode" , py::overload_cast&,const xt::xtensor&>(&M::Vector::asNode , py::const_), "Set 'nodevec", py::arg("dofval_u"), py::arg("dofval_p")) + .def("asNode" , py::overload_cast& >(&M::Vector::asNode , py::const_), "Set 'nodevec", py::arg("dofval")) + .def("asNode" , py::overload_cast& >(&M::Vector::asNode , py::const_), "Set 'nodevec", py::arg("elemvec")) + + .def("asElement", py::overload_cast&,const xt::xtensor&>(&M::Vector::asElement, py::const_), "Set 'elemvec", py::arg("dofval_u"), py::arg("dofval_p")) + .def("asElement", py::overload_cast& >(&M::Vector::asElement, py::const_), "Set 'elemvec", py::arg("dofval")) + .def("asElement", py::overload_cast& >(&M::Vector::asElement, py::const_), "Set 'elemvec", py::arg("nodevec")) + + .def("assembleDofs" , py::overload_cast&>(&M::Vector::assembleDofs , py::const_), "Assemble 'dofval'" , py::arg("nodevec")) + .def("assembleDofs" , py::overload_cast&>(&M::Vector::assembleDofs , py::const_), "Assemble 'dofval'" , py::arg("elemvec")) + .def("assembleDofs_u", py::overload_cast&>(&M::Vector::assembleDofs_u, py::const_), "Assemble 'dofval'" , py::arg("nodevec")) + .def("assembleDofs_u", py::overload_cast&>(&M::Vector::assembleDofs_u, py::const_), "Assemble 'dofval'" , py::arg("elemvec")) + .def("assembleDofs_p", py::overload_cast&>(&M::Vector::assembleDofs_p, py::const_), "Assemble 'dofval'" , py::arg("nodevec")) + .def("assembleDofs_p", py::overload_cast&>(&M::Vector::assembleDofs_p, py::const_), "Assemble 'dofval'" , py::arg("elemvec")) + + .def("assembleNode" , py::overload_cast&>(&M::Vector::assembleNode , py::const_), "Assemble 'nodevec'", py::arg("elemvec")) + + .def("__repr__", [](const xGooseFEM::Vector &){ return ""; }); // ==================================== GooseFEM.MatrixDiagonal ==================================== -py::class_(m, "MatrixDiagonal") - // - - .def( - py::init &, const xt::xtensor &>(), - "Class to switch between DOF/nodal/element views of vectors", - py::arg("conn"), - py::arg("dofs") - ) - // - - .def( - py::init &, const xt::xtensor &, const xt::xtensor &>(), - "Class to switch between DOF/nodal/element views of vectors", - py::arg("conn"), - py::arg("dofs"), - py::arg("iip") - ) - // - - .def("nelem", &M::MatrixDiagonal::nelem) - .def("nne" , &M::MatrixDiagonal::nne ) - .def("nnode", &M::MatrixDiagonal::nnode) - .def("ndim" , &M::MatrixDiagonal::ndim ) - .def("ndof" , &M::MatrixDiagonal::ndof ) - .def("nnu" , &M::MatrixDiagonal::nnu ) - .def("nnp" , &M::MatrixDiagonal::nnp ) - // - - .def("iiu" , &M::MatrixDiagonal::iiu ) - .def("iip" , &M::MatrixDiagonal::iip ) - // - - .def("dot" , &M::MatrixDiagonal::dot ) - .def("dot_u", py::overload_cast& >(&M::MatrixDiagonal::dot_u, py::const_)) - .def("dot_u", py::overload_cast&,const xt::xtensor&>(&M::MatrixDiagonal::dot_u, py::const_)) - .def("dot_p", py::overload_cast& >(&M::MatrixDiagonal::dot_p, py::const_)) - .def("dot_p", py::overload_cast&,const xt::xtensor&>(&M::MatrixDiagonal::dot_p, py::const_)) - // - - .def("check_diagonal", &M::MatrixDiagonal::check_diagonal) - .def("assemble" , &M::MatrixDiagonal::assemble ) - // .def("set" , &M::MatrixDiagonal::set ) - // .def("set_uu" , &M::MatrixDiagonal::set_uu ) - // .def("set_pp" , &M::MatrixDiagonal::set_pp ) - .def("solve" , py::overload_cast& >(&M::MatrixDiagonal::solve ), "Solve", py::arg("rhs" ) ) - .def("solve" , py::overload_cast&, const xt::xtensor&>(&M::MatrixDiagonal::solve ), "Solve", py::arg("rhs" ), py::arg("u_p")) - .def("solve_u" , py::overload_cast& >(&M::MatrixDiagonal::solve_u), "Solve", py::arg("rhs_u") ) - .def("solve_u" , py::overload_cast&, const xt::xtensor&>(&M::MatrixDiagonal::solve_u), "Solve", py::arg("rhs_u"), py::arg("u_p")) - // .def("rhs_p" , &M::MatrixDiagonal::rhs_p ) - .def("asDiagonal" , &M::MatrixDiagonal::asDiagonal ) - // .def("asDiagonal_uu" , &M::MatrixDiagonal::asDiagonal_uu ) - // .def("asDiagonal_pp" , &M::MatrixDiagonal::asDiagonal_pp ) - // .def("asSparse" , &M::MatrixDiagonal::asSparse ) - // .def("asSparse_uu" , &M::MatrixDiagonal::asSparse_uu ) - // .def("asSparse_up" , &M::MatrixDiagonal::asSparse_up ) - // .def("asSparse_pu" , &M::MatrixDiagonal::asSparse_pu ) - // .def("asSparse_pp" , &M::MatrixDiagonal::asSparse_pp ) - // .def("asDense" , &M::MatrixDiagonal::asDense ) - // .def("asDense_uu" , &M::MatrixDiagonal::asDense_uu ) - // .def("asDense_up" , &M::MatrixDiagonal::asDense_up ) - // .def("asDense_pu" , &M::MatrixDiagonal::asDense_pu ) - // .def("asDense_pp" , &M::MatrixDiagonal::asDense_pp ) - - // print to screen - .def("__repr__", - [](const GooseFEM::MatrixDiagonal &){ return ""; } - ); +py::class_(m, "MatrixDiagonal") + + .def(py::init &, const xt::xtensor & >(), "Diagonal matrix", py::arg("conn"), py::arg("dofs")) + .def(py::init &, const xt::xtensor &, const xt::xtensor &>(), "Diagonal matrix", py::arg("conn"), py::arg("dofs"), py::arg("iip")) + + .def("nelem", &M::MatrixDiagonal::nelem, "Return number of element") + .def("nne" , &M::MatrixDiagonal::nne , "Return number of nodes per element") + .def("nnode", &M::MatrixDiagonal::nnode, "Return number of nodes") + .def("ndim" , &M::MatrixDiagonal::ndim , "Return number of dimensions") + .def("ndof" , &M::MatrixDiagonal::ndof , "Return number of degrees-of-freedom") + .def("nnu" , &M::MatrixDiagonal::nnu , "Return number of unknown degrees-of-freedom") + .def("nnp" , &M::MatrixDiagonal::nnp , "Return number of prescribed degrees-of-freedom") + + .def("dofs" , &M::MatrixDiagonal::dofs , "Return degrees-of-freedom") + .def("iiu" , &M::MatrixDiagonal::iiu , "Return unknown degrees-of-freedom") + .def("iip" , &M::MatrixDiagonal::iip , "Return prescribed degrees-of-freedom") + + .def("dot" , &M::MatrixDiagonal::dot , "Dot product 'b_i = A_ij * x_j", py::arg("x")) + .def("dot_u", &M::MatrixDiagonal::dot_u, "Dot product 'b_i = A_ij * x_j", py::arg("x_u"), py::arg("x_p")) + .def("dot_p", &M::MatrixDiagonal::dot_p, "Dot product 'b_i = A_ij * x_j", py::arg("x_u"), py::arg("x_p")) + + .def("assemble", &M::MatrixDiagonal::assemble, "Assemble from 'elemmat", py::arg("elemmat")) + + .def("solve" , py::overload_cast& >(&M::MatrixDiagonal::solve ), "Solve", py::arg("b" ) ) + .def("solve" , py::overload_cast&, const xt::xtensor&>(&M::MatrixDiagonal::solve ), "Solve", py::arg("b" ), py::arg("x_p")) + .def("solve_u", py::overload_cast&, const xt::xtensor&>(&M::MatrixDiagonal::solve_u), "Solve", py::arg("b_u"), py::arg("x_p")) + + .def("asDiagonal", &M::MatrixDiagonal::asDiagonal, "Return as diagonal matrix (column)") -// =========================== GooseFEM::Dynamics - GooseFEM/Dynamics.h ============================ + .def("__repr__", [](const xGooseFEM::MatrixDiagonal &){ return ""; }); + +// ======================================= GooseFEM.Dynamics ======================================= py::module mDynamics = m.def_submodule("Dynamics", "Solve routines for dynamic FEM"); // ------------------------------------------------------------------------------------------------- -mDynamics.def("Verlet", - &GooseFEM::Dynamics::Verlet, - "Verlet time integration", - py::arg("geometry"), - py::arg("dt"), - py::arg("nstep")=1 -); +mDynamics.def("Verlet" , &xGooseFEM::Dynamics::Verlet , "Verlet time integration" , py::arg("geometry"), py::arg("dt"), py::arg("nstep")=1); +mDynamics.def("velocityVerlet", &xGooseFEM::Dynamics::velocityVerlet, "Velocity-Verlet time integration", py::arg("geometry"), py::arg("dt"), py::arg("nstep")=1); // ------------------------------------------------------------------------------------------------- -mDynamics.def("velocityVerlet", - &GooseFEM::Dynamics::velocityVerlet, - "Velocity-Verlet time integration", - py::arg("geometry"), - py::arg("dt"), - py::arg("nstep")=1 -); - -// // ------------------------------------------------------------------------------------------------- +py::class_(mDynamics, "Geometry") -py::class_(mDynamics, "Geometry") - // constructor .def(py::init<>()) - // methods - .def("solve_A" , &GooseFEM::Dynamics::Geometry::solve_A) - .def("solve_V" , &GooseFEM::Dynamics::Geometry::solve_V) - .def("u" , &GooseFEM::Dynamics::Geometry::u ) - .def("v" , &GooseFEM::Dynamics::Geometry::v ) - .def("a" , &GooseFEM::Dynamics::Geometry::a ) - .def("dofs_u" , &GooseFEM::Dynamics::Geometry::dofs_u ) - .def("dofs_v" , &GooseFEM::Dynamics::Geometry::dofs_v ) - .def("dofs_a" , &GooseFEM::Dynamics::Geometry::dofs_a ) - .def("set_v" , &GooseFEM::Dynamics::Geometry::set_v ) - .def("set_a" , &GooseFEM::Dynamics::Geometry::set_a ) - .def("set_u" , py::overload_cast &>(&GooseFEM::Dynamics::Geometry::set_u)) - .def("set_u" , py::overload_cast &>(&GooseFEM::Dynamics::Geometry::set_u)) - - // print to screen - .def("__repr__", - [](const GooseFEM::Dynamics::Geometry &){ return ""; } - ); -// ============================ GooseFEM::Element - GooseFEM/Element.h ============================= + .def("solve_A" , &xGooseFEM::Dynamics::Geometry::solve_A, "Solve for accelerations (dofval)" ) + .def("solve_V" , &xGooseFEM::Dynamics::Geometry::solve_V, "Solve for velocities (dofval)" ) -py::module mElement = m.def_submodule("Element", "Generic element routines"); + .def("u" , &xGooseFEM::Dynamics::Geometry::u , "Return displacements (nodevec)") + .def("v" , &xGooseFEM::Dynamics::Geometry::v , "Return velocities (nodevec)") + .def("a" , &xGooseFEM::Dynamics::Geometry::a , "Return accelerations (nodevec)") -// ------------------------------------------------------------------------------------------------- + .def("dofs_u" , &xGooseFEM::Dynamics::Geometry::dofs_u , "Return displacements (dofval)" ) + .def("dofs_v" , &xGooseFEM::Dynamics::Geometry::dofs_v , "Return velocities (dofval)" ) + .def("dofs_a" , &xGooseFEM::Dynamics::Geometry::dofs_a , "Return accelerations (dofval)" ) + + .def("set_u" , py::overload_cast &>(&xGooseFEM::Dynamics::Geometry::set_u), "Overwrite displacements", py::arg("dofval" )) + .def("set_u" , py::overload_cast &>(&xGooseFEM::Dynamics::Geometry::set_u), "Overwrite displacements", py::arg("nodevec")) + .def("set_v" , &xGooseFEM::Dynamics::Geometry::set_v , "Overwrite velocities" , py::arg("nodevec")) + .def("set_a" , &xGooseFEM::Dynamics::Geometry::set_a , "Overwrite accelerations", py::arg("nodevec")) + + .def("__repr__", [](const xGooseFEM::Dynamics::Geometry &){ return ""; }); -mElement.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") -); +// ======================================= GooseFEM.Element ======================================== + +py::module mElement = m.def_submodule("Element", "Generic element routines"); // ------------------------------------------------------------------------------------------------- -mElement.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") -); +mElement.def("asElementVector" , &xGooseFEM::Element::asElementVector , "Covert to 'elemvec'", py::arg("conn"), py::arg("nodevec")); +mElement.def("assembleElementVector", &xGooseFEM::Element::assembleNodeVector, "Assemble 'nodevec'" , py::arg("conn"), py::arg("elemvec")); -// ====================== GooseFEM::Element::Quad4 - GooseFEM/ElementQuad4.h ======================= +// ==================================== GooseFEM.Element.Quad4 ===================================== { -// create sub-module py::module sm = mElement.def_submodule("Quad4", "Linear quadrilateral elements (2D)"); -// abbreviate name-space -namespace SM = GooseFEM::Element::Quad4; - // ------------------------------------------------------------------------------------------------- -py::class_(sm, "Quadrature") - // constructor - .def( - py::init &>(), - "Quadrature", - py::arg("x") - ) - // constructor - .def( - py::init &, const xt::xtensor &, const xt::xtensor &>(), - "Quadrature", - py::arg("x"), - py::arg("xi"), - py::arg("w") - ) - // sizes - .def("nelem" , &SM::Quadrature::nelem) - .def("nne" , &SM::Quadrature::nne) - .def("ndim" , &SM::Quadrature::ndim) - .def("nip" , &SM::Quadrature::nip) - .def("dV" , py::overload_cast<>(&SM::Quadrature::dV, py::const_)) - .def("gradN_vector" , py::overload_cast &>(&SM::Quadrature::gradN_vector, py::const_)) - .def("gradN_vector_T" , py::overload_cast &>(&SM::Quadrature::gradN_vector_T, py::const_)) - .def("symGradN_vector" , py::overload_cast &>(&SM::Quadrature::symGradN_vector, py::const_)) - .def("int_N_scalar_NT_dV" , py::overload_cast &>(&SM::Quadrature::int_N_scalar_NT_dV, py::const_)) - .def("int_gradN_dot_tensor2_dV" , py::overload_cast &>(&SM::Quadrature::int_gradN_dot_tensor2_dV, py::const_)) - // print to screen - .def("__repr__", - [](const SM::Quadrature &){ return ""; } - ); +py::class_(sm, "Quadrature") + + .def(py::init &>(), "Quadrature", py::arg("x")) + + .def(py::init &, const xt::xtensor &, const xt::xtensor &>(), "Quadrature", py::arg("x"), py::arg("xi"), py::arg("w")) + + .def("nelem", &xGooseFEM::Element::Quad4::Quadrature::nelem, "Return number of elements" ) + .def("nne" , &xGooseFEM::Element::Quad4::Quadrature::nne , "Return number of nodes per element" ) + .def("ndim" , &xGooseFEM::Element::Quad4::Quadrature::ndim , "Return number of dimensions" ) + .def("nip" , &xGooseFEM::Element::Quad4::Quadrature::nip , "Return number of integration points") + + .def("dV" , py::overload_cast<>(&xGooseFEM::Element::Quad4::Quadrature::dV , py::const_), "Integration point volume (qscalar)") + .def("dVtensor", py::overload_cast<>(&xGooseFEM::Element::Quad4::Quadrature::dVtensor, py::const_), "Integration point volume (qtensor)") + + .def("gradN_vector" , py::overload_cast &>(&xGooseFEM::Element::Quad4::Quadrature::gradN_vector , py::const_), "Dyadic product, returns 'qtensor'", py::arg("elemvec")) + .def("gradN_vector_T" , py::overload_cast &>(&xGooseFEM::Element::Quad4::Quadrature::gradN_vector_T , py::const_), "Dyadic product, returns 'qtensor'", py::arg("elemvec")) + .def("symGradN_vector", py::overload_cast &>(&xGooseFEM::Element::Quad4::Quadrature::symGradN_vector, py::const_), "Dyadic product, returns 'qtensor'", py::arg("elemvec")) + + .def("int_N_scalar_NT_dV" , py::overload_cast &>(&xGooseFEM::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 &>(&xGooseFEM::Element::Quad4::Quadrature::int_gradN_dot_tensor2_dV, py::const_), "Integration, returns 'elemvec'", py::arg("qtensor")) + + .def("__repr__", [](const xGooseFEM::Element::Quad4::Quadrature &){ return ""; }); // ------------------------------------------------------------------------------------------------- { py::module ssm = sm.def_submodule("Gauss", "Gauss quadrature"); -namespace SSM = GooseFEM::Element::Quad4::Gauss; - -ssm.def("nip", &SSM::nip); -ssm.def("xi" , &SSM::xi); -ssm.def("w" , &SSM::w); +ssm.def("nip", &xGooseFEM::Element::Quad4::Gauss::nip, "Return number of integration point" ); +ssm.def("xi" , &xGooseFEM::Element::Quad4::Gauss::xi , "Return integration point coordinates"); +ssm.def("w" , &xGooseFEM::Element::Quad4::Gauss::w , "Return integration point weights" ); } // ------------------------------------------------------------------------------------------------- { py::module ssm = sm.def_submodule("Nodal", "Nodal quadrature"); -namespace SSM = GooseFEM::Element::Quad4::Nodal; - -ssm.def("nip", &SSM::nip); -ssm.def("xi" , &SSM::xi); -ssm.def("w" , &SSM::w); +ssm.def("nip", &xGooseFEM::Element::Quad4::Nodal::nip, "Return number of integration point" ); +ssm.def("xi" , &xGooseFEM::Element::Quad4::Nodal::xi , "Return integration point coordinates"); +ssm.def("w" , &xGooseFEM::Element::Quad4::Nodal::w , "Return integration point weights" ); } // ------------------------------------------------------------------------------------------------- } -// ====================== GooseFEM::Element::Hex8 - GooseFEM/ElementHex8.h ======================= +// ===================================== GooseFEM.Element.Hex8 ===================================== { -// create sub-module py::module sm = mElement.def_submodule("Hex8", "Linear hexahedron (brick) elements (3D)"); -// abbreviate name-space -namespace SM = GooseFEM::Element::Hex8; - // ------------------------------------------------------------------------------------------------- -py::class_(sm, "Quadrature") - // constructor - .def( - py::init &>(), - "Quadrature", - py::arg("x") - ) - // constructor - .def( - py::init &, const xt::xtensor &, const xt::xtensor &>(), - "Quadrature", - py::arg("x"), - py::arg("xi"), - py::arg("w") - ) - // sizes - .def("nelem" , &SM::Quadrature::nelem) - .def("nne" , &SM::Quadrature::nne) - .def("ndim" , &SM::Quadrature::ndim) - .def("nip" , &SM::Quadrature::nip) - .def("dV" , py::overload_cast<>(&SM::Quadrature::dV, py::const_)) - .def("gradN_vector" , py::overload_cast &>(&SM::Quadrature::gradN_vector, py::const_)) - .def("gradN_vector_T" , py::overload_cast &>(&SM::Quadrature::gradN_vector_T, py::const_)) - .def("symGradN_vector" , py::overload_cast &>(&SM::Quadrature::symGradN_vector, py::const_)) - .def("int_N_scalar_NT_dV" , py::overload_cast &>(&SM::Quadrature::int_N_scalar_NT_dV, py::const_)) - .def("int_gradN_dot_tensor2_dV" , py::overload_cast &>(&SM::Quadrature::int_gradN_dot_tensor2_dV, py::const_)) - // print to screen - .def("__repr__", - [](const SM::Quadrature &){ return ""; } - ); +py::class_(sm, "Quadrature") + + .def(py::init &>(), "Quadrature", py::arg("x")) + + .def(py::init &, const xt::xtensor &, const xt::xtensor &>(), "Quadrature", py::arg("x"), py::arg("xi"), py::arg("w")) + + .def("nelem", &xGooseFEM::Element::Hex8::Quadrature::nelem, "Return number of elements" ) + .def("nne" , &xGooseFEM::Element::Hex8::Quadrature::nne , "Return number of nodes per element" ) + .def("ndim" , &xGooseFEM::Element::Hex8::Quadrature::ndim , "Return number of dimensions" ) + .def("nip" , &xGooseFEM::Element::Hex8::Quadrature::nip , "Return number of integration points") + + .def("dV" , py::overload_cast<>(&xGooseFEM::Element::Hex8::Quadrature::dV , py::const_), "Integration point volume (qscalar)") + .def("dVtensor", py::overload_cast<>(&xGooseFEM::Element::Hex8::Quadrature::dVtensor, py::const_), "Integration point volume (qtensor)") + + .def("gradN_vector" , py::overload_cast &>(&xGooseFEM::Element::Hex8::Quadrature::gradN_vector , py::const_), "Dyadic product, returns 'qtensor'", py::arg("elemvec")) + .def("gradN_vector_T" , py::overload_cast &>(&xGooseFEM::Element::Hex8::Quadrature::gradN_vector_T , py::const_), "Dyadic product, returns 'qtensor'", py::arg("elemvec")) + .def("symGradN_vector", py::overload_cast &>(&xGooseFEM::Element::Hex8::Quadrature::symGradN_vector, py::const_), "Dyadic product, returns 'qtensor'", py::arg("elemvec")) + + .def("int_N_scalar_NT_dV" , py::overload_cast &>(&xGooseFEM::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 &>(&xGooseFEM::Element::Hex8::Quadrature::int_gradN_dot_tensor2_dV, py::const_), "Integration, returns 'elemvec'", py::arg("qtensor")) + + .def("__repr__", [](const xGooseFEM::Element::Hex8::Quadrature &){ return ""; }); // ------------------------------------------------------------------------------------------------- { py::module ssm = sm.def_submodule("Gauss", "Gauss quadrature"); -namespace SSM = GooseFEM::Element::Hex8::Gauss; - -ssm.def("nip", &SSM::nip); -ssm.def("xi" , &SSM::xi); -ssm.def("w" , &SSM::w); +ssm.def("nip", &xGooseFEM::Element::Hex8::Gauss::nip, "Return number of integration point" ); +ssm.def("xi" , &xGooseFEM::Element::Hex8::Gauss::xi , "Return integration point coordinates"); +ssm.def("w" , &xGooseFEM::Element::Hex8::Gauss::w , "Return integration point weights" ); } // ------------------------------------------------------------------------------------------------- { py::module ssm = sm.def_submodule("Nodal", "Nodal quadrature"); -namespace SSM = GooseFEM::Element::Hex8::Nodal; - -ssm.def("nip", &SSM::nip); -ssm.def("xi" , &SSM::xi); -ssm.def("w" , &SSM::w); +ssm.def("nip", &xGooseFEM::Element::Hex8::Nodal::nip, "Return number of integration point" ); +ssm.def("xi" , &xGooseFEM::Element::Hex8::Nodal::xi , "Return integration point coordinates"); +ssm.def("w" , &xGooseFEM::Element::Hex8::Nodal::w , "Return integration point weights" ); } // ------------------------------------------------------------------------------------------------- } -// =============================== GooseFEM::Mesh - GooseFEM/Mesh.h ================================ +// ========================================= GooseFEM.Mesh ========================================= py::module mMesh = m.def_submodule("Mesh", "Generic mesh routines"); // ------------------------------------------------------------------------------------------------- -mMesh.def("elem2node", &GooseFEM::Mesh::elem2node, - "Elements connect to each node: [ number of elements , element numbers ]", - py::arg("conn") -); +mMesh.def("dofs", &xGooseFEM::Mesh::dofs, "List with DOF-numbers (in sequential order)", py::arg("nnode"), py::arg("ndim")); -// ------------------------------------------------------------------------------------------------- +mMesh.def("renumber", &xGooseFEM::Mesh::renumber, "Renumber DOF-list to use the lowest possible index", py::arg("dofs")); -mMesh.def("coordination", &GooseFEM::Mesh::coordination, - "Get the coordination number of each node: the number of elements connected to it", - py::arg("conn") -); +mMesh.def("renumber_index", &xGooseFEM::Mesh::renumber_index, "Index-list to renumber", py::arg("dofs")); -// ------------------------------------------------------------------------------------------------- +mMesh.def("reorder", &xGooseFEM::Mesh::reorder, "Renumber DOF-list to begin or end with 'idx'", py::arg("dofs"), py::arg("idx"), py::arg("location")="end"); -mMesh.def("dofs", &GooseFEM::Mesh::dofs, - "List with DOF-numbers (in sequential order)", - py::arg("nnode"), - py::arg("ndim") -); +mMesh.def("reorder_index", &xGooseFEM::Mesh::reorder_index, "Index-list to reorder", py::arg("dofs"), py::arg("idx"), py::arg("location")="end"); -// ------------------------------------------------------------------------------------------------- - -using renumber = xt::xtensor(const xt::xtensor &); +mMesh.def("coordination", &xGooseFEM::Mesh::coordination, "Coordination number of each node", py::arg("conn")); -mMesh.def("renumber", - py::overload_cast &>((renumber*)&GooseFEM::Mesh::renumber), - "Renumber DOF-list to use the lowest possible index", - py::arg("dofs") -); - -// ------------------------------------------------------------------------------------------------- +mMesh.def("elem2node", &xGooseFEM::Mesh::elem2node, "Elements connect to each node", py::arg("conn")); -using reorder = xt::xtensor(const xt::xtensor &, const xt::xtensor&, std::string); - -mMesh.def("reorder", - py::overload_cast&,const xt::xtensor&,std::string>( - (reorder*)&GooseFEM::Mesh::reorder), - "Renumber DOF-list to begin or end with 'idx'", - py::arg("dofs"), - py::arg("idx"), - py::arg("location")="end" -); - -// ========================== GooseFEM::Mesh::Hex8 - GooseFEM/MeshHex8.h =========================== +// ====================================== GooseFEM.Mesh.Hex8 ======================================= { -// create sub-module py::module sm = mMesh.def_submodule("Hex8", "Linear hexahedron (brick) elements (3D)"); -// abbreviate name-space -namespace SM = GooseFEM::Mesh::Hex8; - // ------------------------------------------------------------------------------------------------- -py::class_(sm, "Regular") - // constructor - .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. - ) - // sizes - .def("nelem" , &SM::Regular::nelem ) - .def("nnode" , &SM::Regular::nnode ) - .def("nne" , &SM::Regular::nne ) - .def("ndim" , &SM::Regular::ndim ) - // mesh - .def("coor" , &SM::Regular::coor ) - .def("conn" , &SM::Regular::conn ) - // boundary nodes: planes - .def("nodesFront" , &SM::Regular::nodesFront ) - .def("nodesBack" , &SM::Regular::nodesBack ) - .def("nodesLeft" , &SM::Regular::nodesLeft ) - .def("nodesRight" , &SM::Regular::nodesRight ) - .def("nodesBottom" , &SM::Regular::nodesBottom ) - .def("nodesTop" , &SM::Regular::nodesTop ) - // boundary nodes: faces - .def("nodesFrontFace" , &SM::Regular::nodesFrontFace ) - .def("nodesBackFace" , &SM::Regular::nodesBackFace ) - .def("nodesLeftFace" , &SM::Regular::nodesLeftFace ) - .def("nodesRightFace" , &SM::Regular::nodesRightFace ) - .def("nodesBottomFace" , &SM::Regular::nodesBottomFace ) - .def("nodesTopFace" , &SM::Regular::nodesTopFace ) - // boundary nodes: edges - .def("nodesFrontBottomEdge" , &SM::Regular::nodesFrontBottomEdge ) - .def("nodesFrontTopEdge" , &SM::Regular::nodesFrontTopEdge ) - .def("nodesFrontLeftEdge" , &SM::Regular::nodesFrontLeftEdge ) - .def("nodesFrontRightEdge" , &SM::Regular::nodesFrontRightEdge ) - .def("nodesBackBottomEdge" , &SM::Regular::nodesBackBottomEdge ) - .def("nodesBackTopEdge" , &SM::Regular::nodesBackTopEdge ) - .def("nodesBackLeftEdge" , &SM::Regular::nodesBackLeftEdge ) - .def("nodesBackRightEdge" , &SM::Regular::nodesBackRightEdge ) - .def("nodesBottomLeftEdge" , &SM::Regular::nodesBottomLeftEdge ) - .def("nodesBottomRightEdge" , &SM::Regular::nodesBottomRightEdge ) - .def("nodesTopLeftEdge" , &SM::Regular::nodesTopLeftEdge ) - .def("nodesTopRightEdge" , &SM::Regular::nodesTopRightEdge ) - // boundary nodes: faces (aliases) - .def("nodesBottomFrontEdge" , &SM::Regular::nodesBottomFrontEdge ) - .def("nodesBottomBackEdge" , &SM::Regular::nodesBottomBackEdge ) - .def("nodesTopFrontEdge" , &SM::Regular::nodesTopFrontEdge ) - .def("nodesTopBackEdge" , &SM::Regular::nodesTopBackEdge ) - .def("nodesLeftBottomEdge" , &SM::Regular::nodesLeftBottomEdge ) - .def("nodesLeftFrontEdge" , &SM::Regular::nodesLeftFrontEdge ) - .def("nodesLeftBackEdge" , &SM::Regular::nodesLeftBackEdge ) - .def("nodesLeftTopEdge" , &SM::Regular::nodesLeftTopEdge ) - .def("nodesRightBottomEdge" , &SM::Regular::nodesRightBottomEdge ) - .def("nodesRightTopEdge" , &SM::Regular::nodesRightTopEdge ) - .def("nodesRightFrontEdge" , &SM::Regular::nodesRightFrontEdge ) - .def("nodesRightBackEdge" , &SM::Regular::nodesRightBackEdge ) - // boundary nodes: edges, without corners - .def("nodesFrontBottomOpenEdge" , &SM::Regular::nodesFrontBottomOpenEdge ) - .def("nodesFrontTopOpenEdge" , &SM::Regular::nodesFrontTopOpenEdge ) - .def("nodesFrontLeftOpenEdge" , &SM::Regular::nodesFrontLeftOpenEdge ) - .def("nodesFrontRightOpenEdge" , &SM::Regular::nodesFrontRightOpenEdge ) - .def("nodesBackBottomOpenEdge" , &SM::Regular::nodesBackBottomOpenEdge ) - .def("nodesBackTopOpenEdge" , &SM::Regular::nodesBackTopOpenEdge ) - .def("nodesBackLeftOpenEdge" , &SM::Regular::nodesBackLeftOpenEdge ) - .def("nodesBackRightOpenEdge" , &SM::Regular::nodesBackRightOpenEdge ) - .def("nodesBottomLeftOpenEdge" , &SM::Regular::nodesBottomLeftOpenEdge ) - .def("nodesBottomRightOpenEdge" , &SM::Regular::nodesBottomRightOpenEdge ) - .def("nodesTopLeftOpenEdge" , &SM::Regular::nodesTopLeftOpenEdge ) - .def("nodesTopRightOpenEdge" , &SM::Regular::nodesTopRightOpenEdge ) - // boundary nodes: edges, without corners (aliases) - .def("nodesBottomFrontOpenEdge" , &SM::Regular::nodesBottomFrontOpenEdge ) - .def("nodesBottomBackOpenEdge" , &SM::Regular::nodesBottomBackOpenEdge ) - .def("nodesTopFrontOpenEdge" , &SM::Regular::nodesTopFrontOpenEdge ) - .def("nodesTopBackOpenEdge" , &SM::Regular::nodesTopBackOpenEdge ) - .def("nodesLeftBottomOpenEdge" , &SM::Regular::nodesLeftBottomOpenEdge ) - .def("nodesLeftFrontOpenEdge" , &SM::Regular::nodesLeftFrontOpenEdge ) - .def("nodesLeftBackOpenEdge" , &SM::Regular::nodesLeftBackOpenEdge ) - .def("nodesLeftTopOpenEdge" , &SM::Regular::nodesLeftTopOpenEdge ) - .def("nodesRightBottomOpenEdge" , &SM::Regular::nodesRightBottomOpenEdge ) - .def("nodesRightTopOpenEdge" , &SM::Regular::nodesRightTopOpenEdge ) - .def("nodesRightFrontOpenEdge" , &SM::Regular::nodesRightFrontOpenEdge ) - .def("nodesRightBackOpenEdge" , &SM::Regular::nodesRightBackOpenEdge ) - // boundary nodes: corners - .def("nodesFrontBottomLeftCorner" , &SM::Regular::nodesFrontBottomLeftCorner ) - .def("nodesFrontBottomRightCorner", &SM::Regular::nodesFrontBottomRightCorner) - .def("nodesFrontTopLeftCorner" , &SM::Regular::nodesFrontTopLeftCorner ) - .def("nodesFrontTopRightCorner" , &SM::Regular::nodesFrontTopRightCorner ) - .def("nodesBackBottomLeftCorner" , &SM::Regular::nodesBackBottomLeftCorner ) - .def("nodesBackBottomRightCorner" , &SM::Regular::nodesBackBottomRightCorner ) - .def("nodesBackTopLeftCorner" , &SM::Regular::nodesBackTopLeftCorner ) - .def("nodesBackTopRightCorner" , &SM::Regular::nodesBackTopRightCorner ) - // boundary nodes: corners (aliases) - .def("nodesFrontLeftBottomCorner" , &SM::Regular::nodesFrontLeftBottomCorner ) - .def("nodesBottomFrontLeftCorner" , &SM::Regular::nodesBottomFrontLeftCorner ) - .def("nodesBottomLeftFrontCorner" , &SM::Regular::nodesBottomLeftFrontCorner ) - .def("nodesLeftFrontBottomCorner" , &SM::Regular::nodesLeftFrontBottomCorner ) - .def("nodesLeftBottomFrontCorner" , &SM::Regular::nodesLeftBottomFrontCorner ) - .def("nodesFrontRightBottomCorner", &SM::Regular::nodesFrontRightBottomCorner) - .def("nodesBottomFrontRightCorner", &SM::Regular::nodesBottomFrontRightCorner) - .def("nodesBottomRightFrontCorner", &SM::Regular::nodesBottomRightFrontCorner) - .def("nodesRightFrontBottomCorner", &SM::Regular::nodesRightFrontBottomCorner) - .def("nodesRightBottomFrontCorner", &SM::Regular::nodesRightBottomFrontCorner) - .def("nodesFrontLeftTopCorner" , &SM::Regular::nodesFrontLeftTopCorner ) - .def("nodesTopFrontLeftCorner" , &SM::Regular::nodesTopFrontLeftCorner ) - .def("nodesTopLeftFrontCorner" , &SM::Regular::nodesTopLeftFrontCorner ) - .def("nodesLeftFrontTopCorner" , &SM::Regular::nodesLeftFrontTopCorner ) - .def("nodesLeftTopFrontCorner" , &SM::Regular::nodesLeftTopFrontCorner ) - .def("nodesFrontRightTopCorner" , &SM::Regular::nodesFrontRightTopCorner ) - .def("nodesTopFrontRightCorner" , &SM::Regular::nodesTopFrontRightCorner ) - .def("nodesTopRightFrontCorner" , &SM::Regular::nodesTopRightFrontCorner ) - .def("nodesRightFrontTopCorner" , &SM::Regular::nodesRightFrontTopCorner ) - .def("nodesRightTopFrontCorner" , &SM::Regular::nodesRightTopFrontCorner ) - .def("nodesBackLeftBottomCorner" , &SM::Regular::nodesBackLeftBottomCorner ) - .def("nodesBottomBackLeftCorner" , &SM::Regular::nodesBottomBackLeftCorner ) - .def("nodesBottomLeftBackCorner" , &SM::Regular::nodesBottomLeftBackCorner ) - .def("nodesLeftBackBottomCorner" , &SM::Regular::nodesLeftBackBottomCorner ) - .def("nodesLeftBottomBackCorner" , &SM::Regular::nodesLeftBottomBackCorner ) - .def("nodesBackRightBottomCorner" , &SM::Regular::nodesBackRightBottomCorner ) - .def("nodesBottomBackRightCorner" , &SM::Regular::nodesBottomBackRightCorner ) - .def("nodesBottomRightBackCorner" , &SM::Regular::nodesBottomRightBackCorner ) - .def("nodesRightBackBottomCorner" , &SM::Regular::nodesRightBackBottomCorner ) - .def("nodesRightBottomBackCorner" , &SM::Regular::nodesRightBottomBackCorner ) - .def("nodesBackLeftTopCorner" , &SM::Regular::nodesBackLeftTopCorner ) - .def("nodesTopBackLeftCorner" , &SM::Regular::nodesTopBackLeftCorner ) - .def("nodesTopLeftBackCorner" , &SM::Regular::nodesTopLeftBackCorner ) - .def("nodesLeftBackTopCorner" , &SM::Regular::nodesLeftBackTopCorner ) - .def("nodesLeftTopBackCorner" , &SM::Regular::nodesLeftTopBackCorner ) - .def("nodesBackRightTopCorner" , &SM::Regular::nodesBackRightTopCorner ) - .def("nodesTopBackRightCorner" , &SM::Regular::nodesTopBackRightCorner ) - .def("nodesTopRightBackCorner" , &SM::Regular::nodesTopRightBackCorner ) - .def("nodesRightBackTopCorner" , &SM::Regular::nodesRightBackTopCorner ) - .def("nodesRightTopBackCorner" , &SM::Regular::nodesRightTopBackCorner ) - // periodicity - .def("nodesPeriodic" , &SM::Regular::nodesPeriodic ) - .def("nodesOrigin" , &SM::Regular::nodesOrigin ) - .def("dofs" , &SM::Regular::dofs ) - .def("dofsPeriodic" , &SM::Regular::dofsPeriodic ) - // print to screen - .def("__repr__", - [](const SM::Regular &){ return ""; } - ); +py::class_(sm, "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" , &xGooseFEM::Mesh::Hex8::Regular::nelem ) + .def("nnode" , &xGooseFEM::Mesh::Hex8::Regular::nnode ) + .def("nne" , &xGooseFEM::Mesh::Hex8::Regular::nne ) + .def("ndim" , &xGooseFEM::Mesh::Hex8::Regular::ndim ) + + .def("coor" , &xGooseFEM::Mesh::Hex8::Regular::coor ) + .def("conn" , &xGooseFEM::Mesh::Hex8::Regular::conn ) + + .def("nodesFront" , &xGooseFEM::Mesh::Hex8::Regular::nodesFront ) + .def("nodesBack" , &xGooseFEM::Mesh::Hex8::Regular::nodesBack ) + .def("nodesLeft" , &xGooseFEM::Mesh::Hex8::Regular::nodesLeft ) + .def("nodesRight" , &xGooseFEM::Mesh::Hex8::Regular::nodesRight ) + .def("nodesBottom" , &xGooseFEM::Mesh::Hex8::Regular::nodesBottom ) + .def("nodesTop" , &xGooseFEM::Mesh::Hex8::Regular::nodesTop ) + + .def("nodesFrontFace" , &xGooseFEM::Mesh::Hex8::Regular::nodesFrontFace ) + .def("nodesBackFace" , &xGooseFEM::Mesh::Hex8::Regular::nodesBackFace ) + .def("nodesLeftFace" , &xGooseFEM::Mesh::Hex8::Regular::nodesLeftFace ) + .def("nodesRightFace" , &xGooseFEM::Mesh::Hex8::Regular::nodesRightFace ) + .def("nodesBottomFace" , &xGooseFEM::Mesh::Hex8::Regular::nodesBottomFace ) + .def("nodesTopFace" , &xGooseFEM::Mesh::Hex8::Regular::nodesTopFace ) + + .def("nodesFrontBottomEdge" , &xGooseFEM::Mesh::Hex8::Regular::nodesFrontBottomEdge ) + .def("nodesFrontTopEdge" , &xGooseFEM::Mesh::Hex8::Regular::nodesFrontTopEdge ) + .def("nodesFrontLeftEdge" , &xGooseFEM::Mesh::Hex8::Regular::nodesFrontLeftEdge ) + .def("nodesFrontRightEdge" , &xGooseFEM::Mesh::Hex8::Regular::nodesFrontRightEdge ) + .def("nodesBackBottomEdge" , &xGooseFEM::Mesh::Hex8::Regular::nodesBackBottomEdge ) + .def("nodesBackTopEdge" , &xGooseFEM::Mesh::Hex8::Regular::nodesBackTopEdge ) + .def("nodesBackLeftEdge" , &xGooseFEM::Mesh::Hex8::Regular::nodesBackLeftEdge ) + .def("nodesBackRightEdge" , &xGooseFEM::Mesh::Hex8::Regular::nodesBackRightEdge ) + .def("nodesBottomLeftEdge" , &xGooseFEM::Mesh::Hex8::Regular::nodesBottomLeftEdge ) + .def("nodesBottomRightEdge" , &xGooseFEM::Mesh::Hex8::Regular::nodesBottomRightEdge ) + .def("nodesTopLeftEdge" , &xGooseFEM::Mesh::Hex8::Regular::nodesTopLeftEdge ) + .def("nodesTopRightEdge" , &xGooseFEM::Mesh::Hex8::Regular::nodesTopRightEdge ) + + .def("nodesBottomFrontEdge" , &xGooseFEM::Mesh::Hex8::Regular::nodesBottomFrontEdge ) + .def("nodesBottomBackEdge" , &xGooseFEM::Mesh::Hex8::Regular::nodesBottomBackEdge ) + .def("nodesTopFrontEdge" , &xGooseFEM::Mesh::Hex8::Regular::nodesTopFrontEdge ) + .def("nodesTopBackEdge" , &xGooseFEM::Mesh::Hex8::Regular::nodesTopBackEdge ) + .def("nodesLeftBottomEdge" , &xGooseFEM::Mesh::Hex8::Regular::nodesLeftBottomEdge ) + .def("nodesLeftFrontEdge" , &xGooseFEM::Mesh::Hex8::Regular::nodesLeftFrontEdge ) + .def("nodesLeftBackEdge" , &xGooseFEM::Mesh::Hex8::Regular::nodesLeftBackEdge ) + .def("nodesLeftTopEdge" , &xGooseFEM::Mesh::Hex8::Regular::nodesLeftTopEdge ) + .def("nodesRightBottomEdge" , &xGooseFEM::Mesh::Hex8::Regular::nodesRightBottomEdge ) + .def("nodesRightTopEdge" , &xGooseFEM::Mesh::Hex8::Regular::nodesRightTopEdge ) + .def("nodesRightFrontEdge" , &xGooseFEM::Mesh::Hex8::Regular::nodesRightFrontEdge ) + .def("nodesRightBackEdge" , &xGooseFEM::Mesh::Hex8::Regular::nodesRightBackEdge ) + + .def("nodesFrontBottomOpenEdge" , &xGooseFEM::Mesh::Hex8::Regular::nodesFrontBottomOpenEdge ) + .def("nodesFrontTopOpenEdge" , &xGooseFEM::Mesh::Hex8::Regular::nodesFrontTopOpenEdge ) + .def("nodesFrontLeftOpenEdge" , &xGooseFEM::Mesh::Hex8::Regular::nodesFrontLeftOpenEdge ) + .def("nodesFrontRightOpenEdge" , &xGooseFEM::Mesh::Hex8::Regular::nodesFrontRightOpenEdge ) + .def("nodesBackBottomOpenEdge" , &xGooseFEM::Mesh::Hex8::Regular::nodesBackBottomOpenEdge ) + .def("nodesBackTopOpenEdge" , &xGooseFEM::Mesh::Hex8::Regular::nodesBackTopOpenEdge ) + .def("nodesBackLeftOpenEdge" , &xGooseFEM::Mesh::Hex8::Regular::nodesBackLeftOpenEdge ) + .def("nodesBackRightOpenEdge" , &xGooseFEM::Mesh::Hex8::Regular::nodesBackRightOpenEdge ) + .def("nodesBottomLeftOpenEdge" , &xGooseFEM::Mesh::Hex8::Regular::nodesBottomLeftOpenEdge ) + .def("nodesBottomRightOpenEdge" , &xGooseFEM::Mesh::Hex8::Regular::nodesBottomRightOpenEdge ) + .def("nodesTopLeftOpenEdge" , &xGooseFEM::Mesh::Hex8::Regular::nodesTopLeftOpenEdge ) + .def("nodesTopRightOpenEdge" , &xGooseFEM::Mesh::Hex8::Regular::nodesTopRightOpenEdge ) + + .def("nodesBottomFrontOpenEdge" , &xGooseFEM::Mesh::Hex8::Regular::nodesBottomFrontOpenEdge ) + .def("nodesBottomBackOpenEdge" , &xGooseFEM::Mesh::Hex8::Regular::nodesBottomBackOpenEdge ) + .def("nodesTopFrontOpenEdge" , &xGooseFEM::Mesh::Hex8::Regular::nodesTopFrontOpenEdge ) + .def("nodesTopBackOpenEdge" , &xGooseFEM::Mesh::Hex8::Regular::nodesTopBackOpenEdge ) + .def("nodesLeftBottomOpenEdge" , &xGooseFEM::Mesh::Hex8::Regular::nodesLeftBottomOpenEdge ) + .def("nodesLeftFrontOpenEdge" , &xGooseFEM::Mesh::Hex8::Regular::nodesLeftFrontOpenEdge ) + .def("nodesLeftBackOpenEdge" , &xGooseFEM::Mesh::Hex8::Regular::nodesLeftBackOpenEdge ) + .def("nodesLeftTopOpenEdge" , &xGooseFEM::Mesh::Hex8::Regular::nodesLeftTopOpenEdge ) + .def("nodesRightBottomOpenEdge" , &xGooseFEM::Mesh::Hex8::Regular::nodesRightBottomOpenEdge ) + .def("nodesRightTopOpenEdge" , &xGooseFEM::Mesh::Hex8::Regular::nodesRightTopOpenEdge ) + .def("nodesRightFrontOpenEdge" , &xGooseFEM::Mesh::Hex8::Regular::nodesRightFrontOpenEdge ) + .def("nodesRightBackOpenEdge" , &xGooseFEM::Mesh::Hex8::Regular::nodesRightBackOpenEdge ) + + .def("nodesFrontBottomLeftCorner" , &xGooseFEM::Mesh::Hex8::Regular::nodesFrontBottomLeftCorner ) + .def("nodesFrontBottomRightCorner", &xGooseFEM::Mesh::Hex8::Regular::nodesFrontBottomRightCorner) + .def("nodesFrontTopLeftCorner" , &xGooseFEM::Mesh::Hex8::Regular::nodesFrontTopLeftCorner ) + .def("nodesFrontTopRightCorner" , &xGooseFEM::Mesh::Hex8::Regular::nodesFrontTopRightCorner ) + .def("nodesBackBottomLeftCorner" , &xGooseFEM::Mesh::Hex8::Regular::nodesBackBottomLeftCorner ) + .def("nodesBackBottomRightCorner" , &xGooseFEM::Mesh::Hex8::Regular::nodesBackBottomRightCorner ) + .def("nodesBackTopLeftCorner" , &xGooseFEM::Mesh::Hex8::Regular::nodesBackTopLeftCorner ) + .def("nodesBackTopRightCorner" , &xGooseFEM::Mesh::Hex8::Regular::nodesBackTopRightCorner ) + + .def("nodesFrontLeftBottomCorner" , &xGooseFEM::Mesh::Hex8::Regular::nodesFrontLeftBottomCorner ) + .def("nodesBottomFrontLeftCorner" , &xGooseFEM::Mesh::Hex8::Regular::nodesBottomFrontLeftCorner ) + .def("nodesBottomLeftFrontCorner" , &xGooseFEM::Mesh::Hex8::Regular::nodesBottomLeftFrontCorner ) + .def("nodesLeftFrontBottomCorner" , &xGooseFEM::Mesh::Hex8::Regular::nodesLeftFrontBottomCorner ) + .def("nodesLeftBottomFrontCorner" , &xGooseFEM::Mesh::Hex8::Regular::nodesLeftBottomFrontCorner ) + .def("nodesFrontRightBottomCorner", &xGooseFEM::Mesh::Hex8::Regular::nodesFrontRightBottomCorner) + .def("nodesBottomFrontRightCorner", &xGooseFEM::Mesh::Hex8::Regular::nodesBottomFrontRightCorner) + .def("nodesBottomRightFrontCorner", &xGooseFEM::Mesh::Hex8::Regular::nodesBottomRightFrontCorner) + .def("nodesRightFrontBottomCorner", &xGooseFEM::Mesh::Hex8::Regular::nodesRightFrontBottomCorner) + .def("nodesRightBottomFrontCorner", &xGooseFEM::Mesh::Hex8::Regular::nodesRightBottomFrontCorner) + .def("nodesFrontLeftTopCorner" , &xGooseFEM::Mesh::Hex8::Regular::nodesFrontLeftTopCorner ) + .def("nodesTopFrontLeftCorner" , &xGooseFEM::Mesh::Hex8::Regular::nodesTopFrontLeftCorner ) + .def("nodesTopLeftFrontCorner" , &xGooseFEM::Mesh::Hex8::Regular::nodesTopLeftFrontCorner ) + .def("nodesLeftFrontTopCorner" , &xGooseFEM::Mesh::Hex8::Regular::nodesLeftFrontTopCorner ) + .def("nodesLeftTopFrontCorner" , &xGooseFEM::Mesh::Hex8::Regular::nodesLeftTopFrontCorner ) + .def("nodesFrontRightTopCorner" , &xGooseFEM::Mesh::Hex8::Regular::nodesFrontRightTopCorner ) + .def("nodesTopFrontRightCorner" , &xGooseFEM::Mesh::Hex8::Regular::nodesTopFrontRightCorner ) + .def("nodesTopRightFrontCorner" , &xGooseFEM::Mesh::Hex8::Regular::nodesTopRightFrontCorner ) + .def("nodesRightFrontTopCorner" , &xGooseFEM::Mesh::Hex8::Regular::nodesRightFrontTopCorner ) + .def("nodesRightTopFrontCorner" , &xGooseFEM::Mesh::Hex8::Regular::nodesRightTopFrontCorner ) + .def("nodesBackLeftBottomCorner" , &xGooseFEM::Mesh::Hex8::Regular::nodesBackLeftBottomCorner ) + .def("nodesBottomBackLeftCorner" , &xGooseFEM::Mesh::Hex8::Regular::nodesBottomBackLeftCorner ) + .def("nodesBottomLeftBackCorner" , &xGooseFEM::Mesh::Hex8::Regular::nodesBottomLeftBackCorner ) + .def("nodesLeftBackBottomCorner" , &xGooseFEM::Mesh::Hex8::Regular::nodesLeftBackBottomCorner ) + .def("nodesLeftBottomBackCorner" , &xGooseFEM::Mesh::Hex8::Regular::nodesLeftBottomBackCorner ) + .def("nodesBackRightBottomCorner" , &xGooseFEM::Mesh::Hex8::Regular::nodesBackRightBottomCorner ) + .def("nodesBottomBackRightCorner" , &xGooseFEM::Mesh::Hex8::Regular::nodesBottomBackRightCorner ) + .def("nodesBottomRightBackCorner" , &xGooseFEM::Mesh::Hex8::Regular::nodesBottomRightBackCorner ) + .def("nodesRightBackBottomCorner" , &xGooseFEM::Mesh::Hex8::Regular::nodesRightBackBottomCorner ) + .def("nodesRightBottomBackCorner" , &xGooseFEM::Mesh::Hex8::Regular::nodesRightBottomBackCorner ) + .def("nodesBackLeftTopCorner" , &xGooseFEM::Mesh::Hex8::Regular::nodesBackLeftTopCorner ) + .def("nodesTopBackLeftCorner" , &xGooseFEM::Mesh::Hex8::Regular::nodesTopBackLeftCorner ) + .def("nodesTopLeftBackCorner" , &xGooseFEM::Mesh::Hex8::Regular::nodesTopLeftBackCorner ) + .def("nodesLeftBackTopCorner" , &xGooseFEM::Mesh::Hex8::Regular::nodesLeftBackTopCorner ) + .def("nodesLeftTopBackCorner" , &xGooseFEM::Mesh::Hex8::Regular::nodesLeftTopBackCorner ) + .def("nodesBackRightTopCorner" , &xGooseFEM::Mesh::Hex8::Regular::nodesBackRightTopCorner ) + .def("nodesTopBackRightCorner" , &xGooseFEM::Mesh::Hex8::Regular::nodesTopBackRightCorner ) + .def("nodesTopRightBackCorner" , &xGooseFEM::Mesh::Hex8::Regular::nodesTopRightBackCorner ) + .def("nodesRightBackTopCorner" , &xGooseFEM::Mesh::Hex8::Regular::nodesRightBackTopCorner ) + .def("nodesRightTopBackCorner" , &xGooseFEM::Mesh::Hex8::Regular::nodesRightTopBackCorner ) + + .def("nodesPeriodic" , &xGooseFEM::Mesh::Hex8::Regular::nodesPeriodic ) + .def("nodesOrigin" , &xGooseFEM::Mesh::Hex8::Regular::nodesOrigin ) + .def("dofs" , &xGooseFEM::Mesh::Hex8::Regular::dofs ) + .def("dofsPeriodic" , &xGooseFEM::Mesh::Hex8::Regular::dofsPeriodic ) + + .def("__repr__", [](const xGooseFEM::Mesh::Hex8::Regular &){ return ""; }); // ------------------------------------------------------------------------------------------------- -py::class_(sm, "FineLayer") - // constructor - .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., - py::arg("nfine")=1 - ) - // sizes - .def("nelem" , &SM::FineLayer::nelem ) - .def("nnode" , &SM::FineLayer::nnode ) - .def("nne" , &SM::FineLayer::nne ) - .def("ndim" , &SM::FineLayer::ndim ) - .def("shape" , &SM::FineLayer::shape ) - // mesh - .def("coor" , &SM::FineLayer::coor ) - .def("conn" , &SM::FineLayer::conn ) - // element sets - .def("elementsMiddleLayer" , &SM::FineLayer::elementsMiddleLayer ) - // boundary nodes: planes - .def("nodesFront" , &SM::FineLayer::nodesFront ) - .def("nodesBack" , &SM::FineLayer::nodesBack ) - .def("nodesLeft" , &SM::FineLayer::nodesLeft ) - .def("nodesRight" , &SM::FineLayer::nodesRight ) - .def("nodesBottom" , &SM::FineLayer::nodesBottom ) - .def("nodesTop" , &SM::FineLayer::nodesTop ) - // boundary nodes: faces - .def("nodesFrontFace" , &SM::FineLayer::nodesFrontFace ) - .def("nodesBackFace" , &SM::FineLayer::nodesBackFace ) - .def("nodesLeftFace" , &SM::FineLayer::nodesLeftFace ) - .def("nodesRightFace" , &SM::FineLayer::nodesRightFace ) - .def("nodesBottomFace" , &SM::FineLayer::nodesBottomFace ) - .def("nodesTopFace" , &SM::FineLayer::nodesTopFace ) - // boundary nodes: edges - .def("nodesFrontBottomEdge" , &SM::FineLayer::nodesFrontBottomEdge ) - .def("nodesFrontTopEdge" , &SM::FineLayer::nodesFrontTopEdge ) - .def("nodesFrontLeftEdge" , &SM::FineLayer::nodesFrontLeftEdge ) - .def("nodesFrontRightEdge" , &SM::FineLayer::nodesFrontRightEdge ) - .def("nodesBackBottomEdge" , &SM::FineLayer::nodesBackBottomEdge ) - .def("nodesBackTopEdge" , &SM::FineLayer::nodesBackTopEdge ) - .def("nodesBackLeftEdge" , &SM::FineLayer::nodesBackLeftEdge ) - .def("nodesBackRightEdge" , &SM::FineLayer::nodesBackRightEdge ) - .def("nodesBottomLeftEdge" , &SM::FineLayer::nodesBottomLeftEdge ) - .def("nodesBottomRightEdge" , &SM::FineLayer::nodesBottomRightEdge ) - .def("nodesTopLeftEdge" , &SM::FineLayer::nodesTopLeftEdge ) - .def("nodesTopRightEdge" , &SM::FineLayer::nodesTopRightEdge ) - // boundary nodes: faces (aliases) - .def("nodesBottomFrontEdge" , &SM::FineLayer::nodesBottomFrontEdge ) - .def("nodesBottomBackEdge" , &SM::FineLayer::nodesBottomBackEdge ) - .def("nodesTopFrontEdge" , &SM::FineLayer::nodesTopFrontEdge ) - .def("nodesTopBackEdge" , &SM::FineLayer::nodesTopBackEdge ) - .def("nodesLeftBottomEdge" , &SM::FineLayer::nodesLeftBottomEdge ) - .def("nodesLeftFrontEdge" , &SM::FineLayer::nodesLeftFrontEdge ) - .def("nodesLeftBackEdge" , &SM::FineLayer::nodesLeftBackEdge ) - .def("nodesLeftTopEdge" , &SM::FineLayer::nodesLeftTopEdge ) - .def("nodesRightBottomEdge" , &SM::FineLayer::nodesRightBottomEdge ) - .def("nodesRightTopEdge" , &SM::FineLayer::nodesRightTopEdge ) - .def("nodesRightFrontEdge" , &SM::FineLayer::nodesRightFrontEdge ) - .def("nodesRightBackEdge" , &SM::FineLayer::nodesRightBackEdge ) - // boundary nodes: edges, without corners - .def("nodesFrontBottomOpenEdge" , &SM::FineLayer::nodesFrontBottomOpenEdge ) - .def("nodesFrontTopOpenEdge" , &SM::FineLayer::nodesFrontTopOpenEdge ) - .def("nodesFrontLeftOpenEdge" , &SM::FineLayer::nodesFrontLeftOpenEdge ) - .def("nodesFrontRightOpenEdge" , &SM::FineLayer::nodesFrontRightOpenEdge ) - .def("nodesBackBottomOpenEdge" , &SM::FineLayer::nodesBackBottomOpenEdge ) - .def("nodesBackTopOpenEdge" , &SM::FineLayer::nodesBackTopOpenEdge ) - .def("nodesBackLeftOpenEdge" , &SM::FineLayer::nodesBackLeftOpenEdge ) - .def("nodesBackRightOpenEdge" , &SM::FineLayer::nodesBackRightOpenEdge ) - .def("nodesBottomLeftOpenEdge" , &SM::FineLayer::nodesBottomLeftOpenEdge ) - .def("nodesBottomRightOpenEdge" , &SM::FineLayer::nodesBottomRightOpenEdge ) - .def("nodesTopLeftOpenEdge" , &SM::FineLayer::nodesTopLeftOpenEdge ) - .def("nodesTopRightOpenEdge" , &SM::FineLayer::nodesTopRightOpenEdge ) - // boundary nodes: edges, without corners (aliases) - .def("nodesBottomFrontOpenEdge" , &SM::FineLayer::nodesBottomFrontOpenEdge ) - .def("nodesBottomBackOpenEdge" , &SM::FineLayer::nodesBottomBackOpenEdge ) - .def("nodesTopFrontOpenEdge" , &SM::FineLayer::nodesTopFrontOpenEdge ) - .def("nodesTopBackOpenEdge" , &SM::FineLayer::nodesTopBackOpenEdge ) - .def("nodesLeftBottomOpenEdge" , &SM::FineLayer::nodesLeftBottomOpenEdge ) - .def("nodesLeftFrontOpenEdge" , &SM::FineLayer::nodesLeftFrontOpenEdge ) - .def("nodesLeftBackOpenEdge" , &SM::FineLayer::nodesLeftBackOpenEdge ) - .def("nodesLeftTopOpenEdge" , &SM::FineLayer::nodesLeftTopOpenEdge ) - .def("nodesRightBottomOpenEdge" , &SM::FineLayer::nodesRightBottomOpenEdge ) - .def("nodesRightTopOpenEdge" , &SM::FineLayer::nodesRightTopOpenEdge ) - .def("nodesRightFrontOpenEdge" , &SM::FineLayer::nodesRightFrontOpenEdge ) - .def("nodesRightBackOpenEdge" , &SM::FineLayer::nodesRightBackOpenEdge ) - // boundary nodes: corners - .def("nodesFrontBottomLeftCorner" , &SM::FineLayer::nodesFrontBottomLeftCorner ) - .def("nodesFrontBottomRightCorner", &SM::FineLayer::nodesFrontBottomRightCorner) - .def("nodesFrontTopLeftCorner" , &SM::FineLayer::nodesFrontTopLeftCorner ) - .def("nodesFrontTopRightCorner" , &SM::FineLayer::nodesFrontTopRightCorner ) - .def("nodesBackBottomLeftCorner" , &SM::FineLayer::nodesBackBottomLeftCorner ) - .def("nodesBackBottomRightCorner" , &SM::FineLayer::nodesBackBottomRightCorner ) - .def("nodesBackTopLeftCorner" , &SM::FineLayer::nodesBackTopLeftCorner ) - .def("nodesBackTopRightCorner" , &SM::FineLayer::nodesBackTopRightCorner ) - // boundary nodes: corners (aliases) - .def("nodesFrontLeftBottomCorner" , &SM::FineLayer::nodesFrontLeftBottomCorner ) - .def("nodesBottomFrontLeftCorner" , &SM::FineLayer::nodesBottomFrontLeftCorner ) - .def("nodesBottomLeftFrontCorner" , &SM::FineLayer::nodesBottomLeftFrontCorner ) - .def("nodesLeftFrontBottomCorner" , &SM::FineLayer::nodesLeftFrontBottomCorner ) - .def("nodesLeftBottomFrontCorner" , &SM::FineLayer::nodesLeftBottomFrontCorner ) - .def("nodesFrontRightBottomCorner", &SM::FineLayer::nodesFrontRightBottomCorner) - .def("nodesBottomFrontRightCorner", &SM::FineLayer::nodesBottomFrontRightCorner) - .def("nodesBottomRightFrontCorner", &SM::FineLayer::nodesBottomRightFrontCorner) - .def("nodesRightFrontBottomCorner", &SM::FineLayer::nodesRightFrontBottomCorner) - .def("nodesRightBottomFrontCorner", &SM::FineLayer::nodesRightBottomFrontCorner) - .def("nodesFrontLeftTopCorner" , &SM::FineLayer::nodesFrontLeftTopCorner ) - .def("nodesTopFrontLeftCorner" , &SM::FineLayer::nodesTopFrontLeftCorner ) - .def("nodesTopLeftFrontCorner" , &SM::FineLayer::nodesTopLeftFrontCorner ) - .def("nodesLeftFrontTopCorner" , &SM::FineLayer::nodesLeftFrontTopCorner ) - .def("nodesLeftTopFrontCorner" , &SM::FineLayer::nodesLeftTopFrontCorner ) - .def("nodesFrontRightTopCorner" , &SM::FineLayer::nodesFrontRightTopCorner ) - .def("nodesTopFrontRightCorner" , &SM::FineLayer::nodesTopFrontRightCorner ) - .def("nodesTopRightFrontCorner" , &SM::FineLayer::nodesTopRightFrontCorner ) - .def("nodesRightFrontTopCorner" , &SM::FineLayer::nodesRightFrontTopCorner ) - .def("nodesRightTopFrontCorner" , &SM::FineLayer::nodesRightTopFrontCorner ) - .def("nodesBackLeftBottomCorner" , &SM::FineLayer::nodesBackLeftBottomCorner ) - .def("nodesBottomBackLeftCorner" , &SM::FineLayer::nodesBottomBackLeftCorner ) - .def("nodesBottomLeftBackCorner" , &SM::FineLayer::nodesBottomLeftBackCorner ) - .def("nodesLeftBackBottomCorner" , &SM::FineLayer::nodesLeftBackBottomCorner ) - .def("nodesLeftBottomBackCorner" , &SM::FineLayer::nodesLeftBottomBackCorner ) - .def("nodesBackRightBottomCorner" , &SM::FineLayer::nodesBackRightBottomCorner ) - .def("nodesBottomBackRightCorner" , &SM::FineLayer::nodesBottomBackRightCorner ) - .def("nodesBottomRightBackCorner" , &SM::FineLayer::nodesBottomRightBackCorner ) - .def("nodesRightBackBottomCorner" , &SM::FineLayer::nodesRightBackBottomCorner ) - .def("nodesRightBottomBackCorner" , &SM::FineLayer::nodesRightBottomBackCorner ) - .def("nodesBackLeftTopCorner" , &SM::FineLayer::nodesBackLeftTopCorner ) - .def("nodesTopBackLeftCorner" , &SM::FineLayer::nodesTopBackLeftCorner ) - .def("nodesTopLeftBackCorner" , &SM::FineLayer::nodesTopLeftBackCorner ) - .def("nodesLeftBackTopCorner" , &SM::FineLayer::nodesLeftBackTopCorner ) - .def("nodesLeftTopBackCorner" , &SM::FineLayer::nodesLeftTopBackCorner ) - .def("nodesBackRightTopCorner" , &SM::FineLayer::nodesBackRightTopCorner ) - .def("nodesTopBackRightCorner" , &SM::FineLayer::nodesTopBackRightCorner ) - .def("nodesTopRightBackCorner" , &SM::FineLayer::nodesTopRightBackCorner ) - .def("nodesRightBackTopCorner" , &SM::FineLayer::nodesRightBackTopCorner ) - .def("nodesRightTopBackCorner" , &SM::FineLayer::nodesRightTopBackCorner ) - // periodicity - .def("nodesPeriodic" , &SM::FineLayer::nodesPeriodic ) - .def("nodesOrigin" , &SM::FineLayer::nodesOrigin ) - .def("dofs" , &SM::FineLayer::dofs ) - .def("dofsPeriodic" , &SM::FineLayer::dofsPeriodic ) - // print to screen - .def("__repr__", - [](const SM::FineLayer &){ return ""; } - ); +py::class_(sm, "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., py::arg("nfine")=1) + + .def("nelem" , &xGooseFEM::Mesh::Hex8::FineLayer::nelem ) + .def("nnode" , &xGooseFEM::Mesh::Hex8::FineLayer::nnode ) + .def("nne" , &xGooseFEM::Mesh::Hex8::FineLayer::nne ) + .def("ndim" , &xGooseFEM::Mesh::Hex8::FineLayer::ndim ) + .def("shape" , &xGooseFEM::Mesh::Hex8::FineLayer::shape ) + + .def("coor" , &xGooseFEM::Mesh::Hex8::FineLayer::coor ) + .def("conn" , &xGooseFEM::Mesh::Hex8::FineLayer::conn ) + + .def("elementsMiddleLayer" , &xGooseFEM::Mesh::Hex8::FineLayer::elementsMiddleLayer ) + + .def("nodesFront" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesFront ) + .def("nodesBack" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesBack ) + .def("nodesLeft" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesLeft ) + .def("nodesRight" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesRight ) + .def("nodesBottom" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesBottom ) + .def("nodesTop" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesTop ) + + .def("nodesFrontFace" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesFrontFace ) + .def("nodesBackFace" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesBackFace ) + .def("nodesLeftFace" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesLeftFace ) + .def("nodesRightFace" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesRightFace ) + .def("nodesBottomFace" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesBottomFace ) + .def("nodesTopFace" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesTopFace ) + + .def("nodesFrontBottomEdge" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesFrontBottomEdge ) + .def("nodesFrontTopEdge" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesFrontTopEdge ) + .def("nodesFrontLeftEdge" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesFrontLeftEdge ) + .def("nodesFrontRightEdge" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesFrontRightEdge ) + .def("nodesBackBottomEdge" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesBackBottomEdge ) + .def("nodesBackTopEdge" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesBackTopEdge ) + .def("nodesBackLeftEdge" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesBackLeftEdge ) + .def("nodesBackRightEdge" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesBackRightEdge ) + .def("nodesBottomLeftEdge" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesBottomLeftEdge ) + .def("nodesBottomRightEdge" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesBottomRightEdge ) + .def("nodesTopLeftEdge" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesTopLeftEdge ) + .def("nodesTopRightEdge" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesTopRightEdge ) + + .def("nodesBottomFrontEdge" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesBottomFrontEdge ) + .def("nodesBottomBackEdge" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesBottomBackEdge ) + .def("nodesTopFrontEdge" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesTopFrontEdge ) + .def("nodesTopBackEdge" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesTopBackEdge ) + .def("nodesLeftBottomEdge" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesLeftBottomEdge ) + .def("nodesLeftFrontEdge" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesLeftFrontEdge ) + .def("nodesLeftBackEdge" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesLeftBackEdge ) + .def("nodesLeftTopEdge" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesLeftTopEdge ) + .def("nodesRightBottomEdge" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesRightBottomEdge ) + .def("nodesRightTopEdge" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesRightTopEdge ) + .def("nodesRightFrontEdge" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesRightFrontEdge ) + .def("nodesRightBackEdge" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesRightBackEdge ) + + .def("nodesFrontBottomOpenEdge" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesFrontBottomOpenEdge ) + .def("nodesFrontTopOpenEdge" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesFrontTopOpenEdge ) + .def("nodesFrontLeftOpenEdge" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesFrontLeftOpenEdge ) + .def("nodesFrontRightOpenEdge" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesFrontRightOpenEdge ) + .def("nodesBackBottomOpenEdge" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesBackBottomOpenEdge ) + .def("nodesBackTopOpenEdge" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesBackTopOpenEdge ) + .def("nodesBackLeftOpenEdge" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesBackLeftOpenEdge ) + .def("nodesBackRightOpenEdge" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesBackRightOpenEdge ) + .def("nodesBottomLeftOpenEdge" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesBottomLeftOpenEdge ) + .def("nodesBottomRightOpenEdge" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesBottomRightOpenEdge ) + .def("nodesTopLeftOpenEdge" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesTopLeftOpenEdge ) + .def("nodesTopRightOpenEdge" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesTopRightOpenEdge ) + + .def("nodesBottomFrontOpenEdge" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesBottomFrontOpenEdge ) + .def("nodesBottomBackOpenEdge" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesBottomBackOpenEdge ) + .def("nodesTopFrontOpenEdge" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesTopFrontOpenEdge ) + .def("nodesTopBackOpenEdge" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesTopBackOpenEdge ) + .def("nodesLeftBottomOpenEdge" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesLeftBottomOpenEdge ) + .def("nodesLeftFrontOpenEdge" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesLeftFrontOpenEdge ) + .def("nodesLeftBackOpenEdge" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesLeftBackOpenEdge ) + .def("nodesLeftTopOpenEdge" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesLeftTopOpenEdge ) + .def("nodesRightBottomOpenEdge" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesRightBottomOpenEdge ) + .def("nodesRightTopOpenEdge" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesRightTopOpenEdge ) + .def("nodesRightFrontOpenEdge" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesRightFrontOpenEdge ) + .def("nodesRightBackOpenEdge" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesRightBackOpenEdge ) + + .def("nodesFrontBottomLeftCorner" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesFrontBottomLeftCorner ) + .def("nodesFrontBottomRightCorner", &xGooseFEM::Mesh::Hex8::FineLayer::nodesFrontBottomRightCorner) + .def("nodesFrontTopLeftCorner" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesFrontTopLeftCorner ) + .def("nodesFrontTopRightCorner" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesFrontTopRightCorner ) + .def("nodesBackBottomLeftCorner" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesBackBottomLeftCorner ) + .def("nodesBackBottomRightCorner" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesBackBottomRightCorner ) + .def("nodesBackTopLeftCorner" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesBackTopLeftCorner ) + .def("nodesBackTopRightCorner" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesBackTopRightCorner ) + + .def("nodesFrontLeftBottomCorner" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesFrontLeftBottomCorner ) + .def("nodesBottomFrontLeftCorner" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesBottomFrontLeftCorner ) + .def("nodesBottomLeftFrontCorner" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesBottomLeftFrontCorner ) + .def("nodesLeftFrontBottomCorner" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesLeftFrontBottomCorner ) + .def("nodesLeftBottomFrontCorner" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesLeftBottomFrontCorner ) + .def("nodesFrontRightBottomCorner", &xGooseFEM::Mesh::Hex8::FineLayer::nodesFrontRightBottomCorner) + .def("nodesBottomFrontRightCorner", &xGooseFEM::Mesh::Hex8::FineLayer::nodesBottomFrontRightCorner) + .def("nodesBottomRightFrontCorner", &xGooseFEM::Mesh::Hex8::FineLayer::nodesBottomRightFrontCorner) + .def("nodesRightFrontBottomCorner", &xGooseFEM::Mesh::Hex8::FineLayer::nodesRightFrontBottomCorner) + .def("nodesRightBottomFrontCorner", &xGooseFEM::Mesh::Hex8::FineLayer::nodesRightBottomFrontCorner) + .def("nodesFrontLeftTopCorner" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesFrontLeftTopCorner ) + .def("nodesTopFrontLeftCorner" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesTopFrontLeftCorner ) + .def("nodesTopLeftFrontCorner" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesTopLeftFrontCorner ) + .def("nodesLeftFrontTopCorner" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesLeftFrontTopCorner ) + .def("nodesLeftTopFrontCorner" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesLeftTopFrontCorner ) + .def("nodesFrontRightTopCorner" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesFrontRightTopCorner ) + .def("nodesTopFrontRightCorner" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesTopFrontRightCorner ) + .def("nodesTopRightFrontCorner" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesTopRightFrontCorner ) + .def("nodesRightFrontTopCorner" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesRightFrontTopCorner ) + .def("nodesRightTopFrontCorner" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesRightTopFrontCorner ) + .def("nodesBackLeftBottomCorner" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesBackLeftBottomCorner ) + .def("nodesBottomBackLeftCorner" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesBottomBackLeftCorner ) + .def("nodesBottomLeftBackCorner" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesBottomLeftBackCorner ) + .def("nodesLeftBackBottomCorner" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesLeftBackBottomCorner ) + .def("nodesLeftBottomBackCorner" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesLeftBottomBackCorner ) + .def("nodesBackRightBottomCorner" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesBackRightBottomCorner ) + .def("nodesBottomBackRightCorner" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesBottomBackRightCorner ) + .def("nodesBottomRightBackCorner" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesBottomRightBackCorner ) + .def("nodesRightBackBottomCorner" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesRightBackBottomCorner ) + .def("nodesRightBottomBackCorner" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesRightBottomBackCorner ) + .def("nodesBackLeftTopCorner" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesBackLeftTopCorner ) + .def("nodesTopBackLeftCorner" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesTopBackLeftCorner ) + .def("nodesTopLeftBackCorner" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesTopLeftBackCorner ) + .def("nodesLeftBackTopCorner" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesLeftBackTopCorner ) + .def("nodesLeftTopBackCorner" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesLeftTopBackCorner ) + .def("nodesBackRightTopCorner" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesBackRightTopCorner ) + .def("nodesTopBackRightCorner" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesTopBackRightCorner ) + .def("nodesTopRightBackCorner" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesTopRightBackCorner ) + .def("nodesRightBackTopCorner" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesRightBackTopCorner ) + .def("nodesRightTopBackCorner" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesRightTopBackCorner ) + + .def("nodesPeriodic" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesPeriodic ) + .def("nodesOrigin" , &xGooseFEM::Mesh::Hex8::FineLayer::nodesOrigin ) + + .def("dofs" , &xGooseFEM::Mesh::Hex8::FineLayer::dofs ) + .def("dofsPeriodic" , &xGooseFEM::Mesh::Hex8::FineLayer::dofsPeriodic ) + + .def("__repr__", [](const xGooseFEM::Mesh::Hex8::FineLayer &){ return ""; }); // ------------------------------------------------------------------------------------------------- } -// ========================= GooseFEM::Mesh::Quad4 - GooseFEM/MeshQuad4.h ========================== +// ====================================== GooseFEM.Mesh.Quad4 ====================================== { -// create sub-module py::module sm = mMesh.def_submodule("Quad4", "Linear quadrilateral elements (2D)"); -// abbreviate name-space -namespace SM = GooseFEM::Mesh::Quad4; - // ------------------------------------------------------------------------------------------------- -py::class_(sm, "Regular") +py::class_(sm, "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(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" , &SM::Regular::coor ) - .def("conn" , &SM::Regular::conn ) - .def("nelem" , &SM::Regular::nelem ) - .def("nnode" , &SM::Regular::nnode ) - .def("nne" , &SM::Regular::nne ) - .def("ndim" , &SM::Regular::ndim ) - .def("nodesBottomEdge" , &SM::Regular::nodesBottomEdge ) - .def("nodesTopEdge" , &SM::Regular::nodesTopEdge ) - .def("nodesLeftEdge" , &SM::Regular::nodesLeftEdge ) - .def("nodesRightEdge" , &SM::Regular::nodesRightEdge ) - .def("nodesBottomOpenEdge" , &SM::Regular::nodesBottomOpenEdge ) - .def("nodesTopOpenEdge" , &SM::Regular::nodesTopOpenEdge ) - .def("nodesLeftOpenEdge" , &SM::Regular::nodesLeftOpenEdge ) - .def("nodesRightOpenEdge" , &SM::Regular::nodesRightOpenEdge ) - .def("nodesBottomLeftCorner" , &SM::Regular::nodesBottomLeftCorner ) - .def("nodesBottomRightCorner", &SM::Regular::nodesBottomRightCorner) - .def("nodesTopLeftCorner" , &SM::Regular::nodesTopLeftCorner ) - .def("nodesTopRightCorner" , &SM::Regular::nodesTopRightCorner ) - .def("nodesLeftBottomCorner" , &SM::Regular::nodesLeftBottomCorner ) - .def("nodesLeftTopCorner" , &SM::Regular::nodesLeftTopCorner ) - .def("nodesRightBottomCorner", &SM::Regular::nodesRightBottomCorner) - .def("nodesRightTopCorner" , &SM::Regular::nodesRightTopCorner ) - .def("nodesPeriodic" , &SM::Regular::nodesPeriodic ) - .def("nodesOrigin" , &SM::Regular::nodesOrigin ) - .def("dofs" , &SM::Regular::dofs ) - .def("dofsPeriodic" , &SM::Regular::dofsPeriodic ) + .def("coor" , &xGooseFEM::Mesh::Quad4::Regular::coor ) + .def("conn" , &xGooseFEM::Mesh::Quad4::Regular::conn ) + .def("nelem" , &xGooseFEM::Mesh::Quad4::Regular::nelem ) + .def("nnode" , &xGooseFEM::Mesh::Quad4::Regular::nnode ) + .def("nne" , &xGooseFEM::Mesh::Quad4::Regular::nne ) + .def("ndim" , &xGooseFEM::Mesh::Quad4::Regular::ndim ) - .def("__repr__", - [](const SM::Regular &){ return ""; } - ); + .def("nodesBottomEdge" , &xGooseFEM::Mesh::Quad4::Regular::nodesBottomEdge ) + .def("nodesTopEdge" , &xGooseFEM::Mesh::Quad4::Regular::nodesTopEdge ) + .def("nodesLeftEdge" , &xGooseFEM::Mesh::Quad4::Regular::nodesLeftEdge ) + .def("nodesRightEdge" , &xGooseFEM::Mesh::Quad4::Regular::nodesRightEdge ) + .def("nodesBottomOpenEdge" , &xGooseFEM::Mesh::Quad4::Regular::nodesBottomOpenEdge ) + .def("nodesTopOpenEdge" , &xGooseFEM::Mesh::Quad4::Regular::nodesTopOpenEdge ) + .def("nodesLeftOpenEdge" , &xGooseFEM::Mesh::Quad4::Regular::nodesLeftOpenEdge ) + .def("nodesRightOpenEdge" , &xGooseFEM::Mesh::Quad4::Regular::nodesRightOpenEdge ) + + .def("nodesBottomLeftCorner" , &xGooseFEM::Mesh::Quad4::Regular::nodesBottomLeftCorner ) + .def("nodesBottomRightCorner", &xGooseFEM::Mesh::Quad4::Regular::nodesBottomRightCorner) + .def("nodesTopLeftCorner" , &xGooseFEM::Mesh::Quad4::Regular::nodesTopLeftCorner ) + .def("nodesTopRightCorner" , &xGooseFEM::Mesh::Quad4::Regular::nodesTopRightCorner ) + .def("nodesLeftBottomCorner" , &xGooseFEM::Mesh::Quad4::Regular::nodesLeftBottomCorner ) + .def("nodesLeftTopCorner" , &xGooseFEM::Mesh::Quad4::Regular::nodesLeftTopCorner ) + .def("nodesRightBottomCorner", &xGooseFEM::Mesh::Quad4::Regular::nodesRightBottomCorner) + .def("nodesRightTopCorner" , &xGooseFEM::Mesh::Quad4::Regular::nodesRightTopCorner ) + + .def("nodesPeriodic" , &xGooseFEM::Mesh::Quad4::Regular::nodesPeriodic ) + .def("nodesOrigin" , &xGooseFEM::Mesh::Quad4::Regular::nodesOrigin ) + + .def("dofs" , &xGooseFEM::Mesh::Quad4::Regular::dofs ) + .def("dofsPeriodic" , &xGooseFEM::Mesh::Quad4::Regular::dofsPeriodic ) + + .def("__repr__", [](const xGooseFEM::Mesh::Quad4::Regular &){ return ""; }); // ------------------------------------------------------------------------------------------------- -py::class_(sm, "FineLayer") +py::class_(sm, "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("shape" , &SM::FineLayer::shape ) - .def("coor" , &SM::FineLayer::coor ) - .def("conn" , &SM::FineLayer::conn ) - .def("nelem" , &SM::FineLayer::nelem ) - .def("nnode" , &SM::FineLayer::nnode ) - .def("nne" , &SM::FineLayer::nne ) - .def("ndim" , &SM::FineLayer::ndim ) - .def("elementsMiddleLayer" , &SM::FineLayer::elementsMiddleLayer ) - .def("nodesBottomEdge" , &SM::FineLayer::nodesBottomEdge ) - .def("nodesTopEdge" , &SM::FineLayer::nodesTopEdge ) - .def("nodesLeftEdge" , &SM::FineLayer::nodesLeftEdge ) - .def("nodesRightEdge" , &SM::FineLayer::nodesRightEdge ) - .def("nodesBottomOpenEdge" , &SM::FineLayer::nodesBottomOpenEdge ) - .def("nodesTopOpenEdge" , &SM::FineLayer::nodesTopOpenEdge ) - .def("nodesLeftOpenEdge" , &SM::FineLayer::nodesLeftOpenEdge ) - .def("nodesRightOpenEdge" , &SM::FineLayer::nodesRightOpenEdge ) - .def("nodesBottomLeftCorner" , &SM::FineLayer::nodesBottomLeftCorner ) - .def("nodesBottomRightCorner", &SM::FineLayer::nodesBottomRightCorner) - .def("nodesTopLeftCorner" , &SM::FineLayer::nodesTopLeftCorner ) - .def("nodesTopRightCorner" , &SM::FineLayer::nodesTopRightCorner ) - .def("nodesLeftBottomCorner" , &SM::FineLayer::nodesLeftBottomCorner ) - .def("nodesLeftTopCorner" , &SM::FineLayer::nodesLeftTopCorner ) - .def("nodesRightBottomCorner", &SM::FineLayer::nodesRightBottomCorner) - .def("nodesRightTopCorner" , &SM::FineLayer::nodesRightTopCorner ) - .def("nodesPeriodic" , &SM::FineLayer::nodesPeriodic ) - .def("nodesOrigin" , &SM::FineLayer::nodesOrigin ) - .def("dofs" , &SM::FineLayer::dofs ) - .def("dofsPeriodic" , &SM::FineLayer::dofsPeriodic ) + .def("shape" , &xGooseFEM::Mesh::Quad4::FineLayer::shape ) + .def("coor" , &xGooseFEM::Mesh::Quad4::FineLayer::coor ) + .def("conn" , &xGooseFEM::Mesh::Quad4::FineLayer::conn ) + .def("nelem" , &xGooseFEM::Mesh::Quad4::FineLayer::nelem ) + .def("nnode" , &xGooseFEM::Mesh::Quad4::FineLayer::nnode ) + .def("nne" , &xGooseFEM::Mesh::Quad4::FineLayer::nne ) + .def("ndim" , &xGooseFEM::Mesh::Quad4::FineLayer::ndim ) + .def("elementsMiddleLayer" , &xGooseFEM::Mesh::Quad4::FineLayer::elementsMiddleLayer ) + .def("nodesBottomEdge" , &xGooseFEM::Mesh::Quad4::FineLayer::nodesBottomEdge ) + .def("nodesTopEdge" , &xGooseFEM::Mesh::Quad4::FineLayer::nodesTopEdge ) + .def("nodesLeftEdge" , &xGooseFEM::Mesh::Quad4::FineLayer::nodesLeftEdge ) + .def("nodesRightEdge" , &xGooseFEM::Mesh::Quad4::FineLayer::nodesRightEdge ) + .def("nodesBottomOpenEdge" , &xGooseFEM::Mesh::Quad4::FineLayer::nodesBottomOpenEdge ) + .def("nodesTopOpenEdge" , &xGooseFEM::Mesh::Quad4::FineLayer::nodesTopOpenEdge ) + .def("nodesLeftOpenEdge" , &xGooseFEM::Mesh::Quad4::FineLayer::nodesLeftOpenEdge ) + .def("nodesRightOpenEdge" , &xGooseFEM::Mesh::Quad4::FineLayer::nodesRightOpenEdge ) + .def("nodesBottomLeftCorner" , &xGooseFEM::Mesh::Quad4::FineLayer::nodesBottomLeftCorner ) + .def("nodesBottomRightCorner", &xGooseFEM::Mesh::Quad4::FineLayer::nodesBottomRightCorner) + .def("nodesTopLeftCorner" , &xGooseFEM::Mesh::Quad4::FineLayer::nodesTopLeftCorner ) + .def("nodesTopRightCorner" , &xGooseFEM::Mesh::Quad4::FineLayer::nodesTopRightCorner ) + .def("nodesLeftBottomCorner" , &xGooseFEM::Mesh::Quad4::FineLayer::nodesLeftBottomCorner ) + .def("nodesLeftTopCorner" , &xGooseFEM::Mesh::Quad4::FineLayer::nodesLeftTopCorner ) + .def("nodesRightBottomCorner", &xGooseFEM::Mesh::Quad4::FineLayer::nodesRightBottomCorner) + .def("nodesRightTopCorner" , &xGooseFEM::Mesh::Quad4::FineLayer::nodesRightTopCorner ) + .def("nodesPeriodic" , &xGooseFEM::Mesh::Quad4::FineLayer::nodesPeriodic ) + .def("nodesOrigin" , &xGooseFEM::Mesh::Quad4::FineLayer::nodesOrigin ) + .def("dofs" , &xGooseFEM::Mesh::Quad4::FineLayer::dofs ) + .def("dofsPeriodic" , &xGooseFEM::Mesh::Quad4::FineLayer::dofsPeriodic ) .def("__repr__", - [](const SM::FineLayer &){ return ""; } + [](const xGooseFEM::Mesh::Quad4::FineLayer &){ return ""; } ); // ------------------------------------------------------------------------------------------------- } -// ========================== GooseFEM::Mesh::Tri3 - GooseFEM/MeshTri3.h =========================== +// ====================================== GooseFEM.Mesh.Tri3 ======================================= { -// create sub-module py::module sm = mMesh.def_submodule("Tri3" , "Linear triangular elements (2D)"); -// abbreviate name-space -namespace SM = GooseFEM::Mesh::Tri3; - // ------------------------------------------------------------------------------------------------- -py::class_(sm, "Regular") +py::class_(sm, "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" , &SM::Regular::coor ) - .def("conn" , &SM::Regular::conn ) - .def("nelem" , &SM::Regular::nelem ) - .def("nnode" , &SM::Regular::nnode ) - .def("nne" , &SM::Regular::nne ) - .def("ndim" , &SM::Regular::ndim ) - .def("nodesBottomEdge" , &SM::Regular::nodesBottomEdge ) - .def("nodesTopEdge" , &SM::Regular::nodesTopEdge ) - .def("nodesLeftEdge" , &SM::Regular::nodesLeftEdge ) - .def("nodesRightEdge" , &SM::Regular::nodesRightEdge ) - .def("nodesBottomOpenEdge" , &SM::Regular::nodesBottomOpenEdge ) - .def("nodesTopOpenEdge" , &SM::Regular::nodesTopOpenEdge ) - .def("nodesLeftOpenEdge" , &SM::Regular::nodesLeftOpenEdge ) - .def("nodesRightOpenEdge" , &SM::Regular::nodesRightOpenEdge ) - .def("nodesBottomLeftCorner" , &SM::Regular::nodesBottomLeftCorner ) - .def("nodesBottomRightCorner", &SM::Regular::nodesBottomRightCorner) - .def("nodesTopLeftCorner" , &SM::Regular::nodesTopLeftCorner ) - .def("nodesTopRightCorner" , &SM::Regular::nodesTopRightCorner ) - .def("nodesLeftBottomCorner" , &SM::Regular::nodesLeftBottomCorner ) - .def("nodesLeftTopCorner" , &SM::Regular::nodesLeftTopCorner ) - .def("nodesRightBottomCorner", &SM::Regular::nodesRightBottomCorner) - .def("nodesRightTopCorner" , &SM::Regular::nodesRightTopCorner ) - .def("nodesPeriodic" , &SM::Regular::nodesPeriodic ) - .def("nodesOrigin" , &SM::Regular::nodesOrigin ) - .def("dofs" , &SM::Regular::dofs ) - .def("dofsPeriodic" , &SM::Regular::dofsPeriodic ) - - .def("__repr__", - [](const SM::Regular &){ return ""; } - ); + .def("coor" , &xGooseFEM::Mesh::Tri3::Regular::coor ) + .def("conn" , &xGooseFEM::Mesh::Tri3::Regular::conn ) + .def("nelem" , &xGooseFEM::Mesh::Tri3::Regular::nelem ) + .def("nnode" , &xGooseFEM::Mesh::Tri3::Regular::nnode ) + .def("nne" , &xGooseFEM::Mesh::Tri3::Regular::nne ) + .def("ndim" , &xGooseFEM::Mesh::Tri3::Regular::ndim ) + + .def("nodesBottomEdge" , &xGooseFEM::Mesh::Tri3::Regular::nodesBottomEdge ) + .def("nodesTopEdge" , &xGooseFEM::Mesh::Tri3::Regular::nodesTopEdge ) + .def("nodesLeftEdge" , &xGooseFEM::Mesh::Tri3::Regular::nodesLeftEdge ) + .def("nodesRightEdge" , &xGooseFEM::Mesh::Tri3::Regular::nodesRightEdge ) + .def("nodesBottomOpenEdge" , &xGooseFEM::Mesh::Tri3::Regular::nodesBottomOpenEdge ) + .def("nodesTopOpenEdge" , &xGooseFEM::Mesh::Tri3::Regular::nodesTopOpenEdge ) + .def("nodesLeftOpenEdge" , &xGooseFEM::Mesh::Tri3::Regular::nodesLeftOpenEdge ) + .def("nodesRightOpenEdge" , &xGooseFEM::Mesh::Tri3::Regular::nodesRightOpenEdge ) + + .def("nodesBottomLeftCorner" , &xGooseFEM::Mesh::Tri3::Regular::nodesBottomLeftCorner ) + .def("nodesBottomRightCorner", &xGooseFEM::Mesh::Tri3::Regular::nodesBottomRightCorner) + .def("nodesTopLeftCorner" , &xGooseFEM::Mesh::Tri3::Regular::nodesTopLeftCorner ) + .def("nodesTopRightCorner" , &xGooseFEM::Mesh::Tri3::Regular::nodesTopRightCorner ) + .def("nodesLeftBottomCorner" , &xGooseFEM::Mesh::Tri3::Regular::nodesLeftBottomCorner ) + .def("nodesLeftTopCorner" , &xGooseFEM::Mesh::Tri3::Regular::nodesLeftTopCorner ) + .def("nodesRightBottomCorner", &xGooseFEM::Mesh::Tri3::Regular::nodesRightBottomCorner) + .def("nodesRightTopCorner" , &xGooseFEM::Mesh::Tri3::Regular::nodesRightTopCorner ) + + .def("nodesPeriodic" , &xGooseFEM::Mesh::Tri3::Regular::nodesPeriodic ) + .def("nodesOrigin" , &xGooseFEM::Mesh::Tri3::Regular::nodesOrigin ) + + .def("dofs" , &xGooseFEM::Mesh::Tri3::Regular::dofs ) + .def("dofsPeriodic" , &xGooseFEM::Mesh::Tri3::Regular::dofsPeriodic ) + + .def("__repr__", [](const xGooseFEM::Mesh::Tri3::Regular &){ return ""; }); // ------------------------------------------------------------------------------------------------- -sm.def("getOrientation",&SM::getOrientation, - "Get the orientation of each element", - py::arg("coor"), - py::arg("conn") -); - -// ------------------------------------------------------------------------------------------------- +sm.def("getOrientation", &xGooseFEM::Mesh::Tri3::getOrientation, "Get the orientation of each element", py::arg("coor"), py::arg("conn")); -sm.def("retriangulate",&SM::retriangulate, - "Re-triangulate existing mesh", - py::arg("coor"), - py::arg("conn"), - py::arg("orientation")=-1 -); +sm.def("retriangulate", &xGooseFEM::Mesh::Tri3::retriangulate, "Re-triangulate existing mesh", py::arg("coor"), py::arg("conn"), py::arg("orientation")=-1); // ------------------------------------------------------------------------------------------------- } // ================================================================================================= } diff --git a/setup.py b/setup.py index ba69979..3a175c3 100644 --- a/setup.py +++ b/setup.py @@ -1,51 +1,51 @@ desc = ''' GooseFEM is a C++ module, wrapped in Python, that provides several predefined finite element meshes. The original C++ module also includes element definitions and several standard finite element simulations. ''' from setuptools import setup, Extension import sys, re import setuptools import pybind11 import pyxtensor -header = open('include/GooseFEM/GooseFEM.h','r').read() -world = re.split(r'(.*)(\#define GOOSEFEM_WORLD_VERSION\ )([0-9]+)(.*)',header)[3] -major = re.split(r'(.*)(\#define GOOSEFEM_MAJOR_VERSION\ )([0-9]+)(.*)',header)[3] -minor = re.split(r'(.*)(\#define GOOSEFEM_MINOR_VERSION\ )([0-9]+)(.*)',header)[3] +header = open('include/xGooseFEM/GooseFEM.h','r').read() +world = re.split(r'(.*)(\#define XGOOSEFEM_WORLD_VERSION\ )([0-9]+)(.*)',header)[3] +major = re.split(r'(.*)(\#define XGOOSEFEM_MAJOR_VERSION\ )([0-9]+)(.*)',header)[3] +minor = re.split(r'(.*)(\#define XGOOSEFEM_MINOR_VERSION\ )([0-9]+)(.*)',header)[3] __version__ = '.'.join([world,major,minor]) ext_modules = [ Extension( 'GooseFEM', - ['include/GooseFEM/python.cpp'], + ['include/xGooseFEM/python.cpp'], include_dirs=[ pybind11 .get_include(False), pybind11 .get_include(True ), pyxtensor.get_include(False), pyxtensor.get_include(True ), pyxtensor.find_xtensor(), pyxtensor.find_xtl(), pyxtensor.find_eigen(), ], language='c++' ), ] setup( name = 'GooseFEM', description = 'Finite element meshes, quadrature, and assembly tools', long_description = desc, version = __version__, license = 'GPLv3', author = 'Tom de Geus', author_email = 'tom@geus.me', url = 'https://github.com/tdegeus/GooseFEM', ext_modules = ext_modules, install_requires = ['pybind11>=2.2.0','pyxtensor>=0.0.1'], cmdclass = {'build_ext': pyxtensor.BuildExt}, zip_safe = False, )