diff --git a/include/GooseFEM/MatrixPartitioned.h b/include/GooseFEM/MatrixPartitioned.h index 1f94a6c..d21edc4 100644 --- a/include/GooseFEM/MatrixPartitioned.h +++ b/include/GooseFEM/MatrixPartitioned.h @@ -1,134 +1,140 @@ /* ================================================================================================= (c - GPLv3) T.W.J. de Geus (Tom) | tom@geus.me | www.geus.me | github.com/tdegeus/GooseFEM ================================================================================================= */ #ifndef GOOSEFEM_MATRIXPARTITIONED_H #define GOOSEFEM_MATRIXPARTITIONED_H // ------------------------------------------------------------------------------------------------- #include "config.h" #include #include #include // ================================================================================================= namespace GooseFEM { // ------------------------------------------------------------------------------------------------- class MatrixPartitioned { public: // constructors MatrixPartitioned() = default; - MatrixPartitioned(const xt::xtensor &conn, const xt::xtensor &dofs, + + MatrixPartitioned( + 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 iiu() const; // unknown DOFs xt::xtensor iip() const; // prescribed DOFs // assemble from matrices stored per element [nelem, nne*ndim, nne*ndim] void assemble(const xt::xtensor &elemmat); // solve: x = A \ b // x_u = A_uu \ ( b_u - A_up * x_p ) // b_p = A_pu * x_u + A_pp * x_p void solve(xt::xtensor &b, xt::xtensor &x); void solve(xt::xtensor &b, xt::xtensor &x); - void solve_u(const xt::xtensor &b_u, const xt::xtensor &x_p, + void solve_u( + const xt::xtensor &b_u, + const xt::xtensor &x_p, xt::xtensor &x_u); // auto allocation of the functions above - xt::xtensor solve_u(const xt::xtensor &b_u, const xt::xtensor &x_p); + xt::xtensor solve_u( + const xt::xtensor &b_u, + const xt::xtensor &x_p); private: // the matrix Eigen::SparseMatrix m_data_uu; Eigen::SparseMatrix m_data_up; Eigen::SparseMatrix m_data_pu; Eigen::SparseMatrix m_data_pp; // the matrix to assemble std::vector> m_trip_uu; std::vector> m_trip_up; std::vector> m_trip_pu; std::vector> m_trip_pp; // solver (re-used to solve different RHS) Eigen::SimplicialLDLT> m_solver; // signal changes to data compare to the last inverse bool m_change=false; // bookkeeping xt::xtensor m_conn; // connectivity [nelem, nne ] xt::xtensor m_dofs; // DOF-numbers per node [nnode, ndim] xt::xtensor m_part; // DOF-numbers per node, renumbered [nnode, ndim] xt::xtensor m_iiu; // DOF-numbers that are unknown [nnu] xt::xtensor m_iip; // DOF-numbers that are prescribed [nnp] // 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 // compute inverse (automatically evaluated by "solve") void factorize(); // convert arrays (Eigen version of VectorPartitioned, which contains public functions) Eigen::VectorXd asDofs_u(const xt::xtensor &dofval) const; Eigen::VectorXd asDofs_u(const xt::xtensor &nodevec) const; Eigen::VectorXd asDofs_p(const xt::xtensor &dofval) const; Eigen::VectorXd asDofs_p(const xt::xtensor &nodevec) const; - }; // ------------------------------------------------------------------------------------------------- } // namespace ... // ================================================================================================= #include "MatrixPartitioned.hpp" // ================================================================================================= #endif diff --git a/include/GooseFEM/Mesh.h b/include/GooseFEM/Mesh.h index d3cfac9..9602576 100644 --- a/include/GooseFEM/Mesh.h +++ b/include/GooseFEM/Mesh.h @@ -1,56 +1,131 @@ /* ================================================================================================= (c - GPLv3) T.W.J. de Geus (Tom) | tom@geus.me | www.geus.me | github.com/tdegeus/GooseFEM ================================================================================================= */ #ifndef GOOSEFEM_MESH_H #define GOOSEFEM_MESH_H // ------------------------------------------------------------------------------------------------- #include "config.h" // ================================================================================================= namespace GooseFEM { namespace Mesh { // ------------------------------------------------------------------------------------------------- +// Renumber to lowest possible index. For example [0,3,4,2] -> [0,2,3,1] + +class Renumber +{ +public: + + // constructors + + Renumber() = default; + + Renumber(const xt::xarray& dofs); + + // get renumbered DOFs (same as "Renumber::apply(dofs)") + + xt::xtensor get(const xt::xtensor& dofs) const; + + // apply renumbering to other set + + template T apply(const T& list) const; + + // get the list needed to renumber, e.g.: + // dofs_renumbered(i,j) = index(dofs(i,j)) + + xt::xtensor index() const; + +private: + + xt::xtensor m_renum; + +}; + +// ------------------------------------------------------------------------------------------------- + +// Reorder to lowest possible index, in specific order. +// +// For example for "Reorder({iiu,iip})" after reordering: +// +// iiu = xt::range(nnu); +// iip = xt::range(nnp) + nnu; + +class Reorder +{ +public: + + // constructors + + Reorder() = default; + + Reorder(const std::initializer_list> args); + + // get reordered DOFs (same as "Reorder::apply(dofs)") + + xt::xtensor get(const xt::xtensor& dofs) const; + + // apply renumbering to other set + + template T apply(const T& list) const; + + // apply renumbering + + // get the list needed to reorder, e.g.: + // dofs_reordered(i,j) = index(dofs(i,j)) + + xt::xtensor index() const; + +private: + + xt::xtensor m_renum; + +}; + +// ------------------------------------------------------------------------------------------------- + // list with DOF-numbers in sequential order inline xt::xtensor dofs(size_t nnode, size_t ndim); +// number of elements connected to each node +inline xt::xtensor coordination(const xt::xtensor &conn); + +// elements connected to each node +inline std::vector> elem2node(const xt::xtensor &conn); + +// ------------------------------------------------------------------------------------------------- + // renumber to lowest possible numbers (e.g. [0,3,4,2] -> [0,2,3,1]) inline xt::xtensor renumber(const xt::xtensor &dofs); // get the list needed to renumber: dofs_renumbered(i,j) = index(dofs(i,j)) inline xt::xtensor renumber_index(const xt::xtensor &dofs); // renumber such that certain indices "iip" are are moved to the beginning or the end // (get the lowest or the highest indices); if "iiu" are the remaining indices, after renumbering: // iiu = arange(nnu), iip = nnu + arange(nnp) inline xt::xtensor reorder(const xt::xtensor &dofs, const xt::xtensor &iip, const std::string &location="end"); // get the list needed to reorder: dofs_reordered(i,j) = index(dofs(i,j)) inline xt::xtensor reorder_index(const xt::xtensor &dofs, const xt::xtensor &iip, const std::string &location="end"); -// number of elements connected to each node -inline xt::xtensor coordination(const xt::xtensor &conn); - -// elements connected to each node -inline std::vector> elem2node(const xt::xtensor &conn); - // ------------------------------------------------------------------------------------------------- }} // namespace ... // ================================================================================================= #include "Mesh.hpp" // ================================================================================================= #endif diff --git a/include/GooseFEM/Mesh.hpp b/include/GooseFEM/Mesh.hpp index c5da9ec..77292ba 100644 --- a/include/GooseFEM/Mesh.hpp +++ b/include/GooseFEM/Mesh.hpp @@ -1,171 +1,233 @@ /* ================================================================================================= (c - GPLv3) T.W.J. de Geus (Tom) | tom@geus.me | www.geus.me | github.com/tdegeus/GooseFEM ================================================================================================= */ #ifndef GOOSEFEM_MESH_HPP #define GOOSEFEM_MESH_HPP // ------------------------------------------------------------------------------------------------- #include "Mesh.h" // ================================================================================================= namespace GooseFEM { namespace Mesh { // ------------------------------------------------------------------------------------------------- -inline xt::xtensor dofs(size_t nnode, size_t ndim) +inline Renumber::Renumber(const xt::xarray& dofs) { - return xt::reshape_view(xt::arange(nnode*ndim),{nnode,ndim}); -} - -// ------------------------------------------------------------------------------------------------- + size_t n = xt::amax(dofs)[0]+1; + size_t i = 0; -inline xt::xtensor renumber_index(const xt::xtensor &dofs) -{ - // get unique list of DOFs xt::xtensor unique = xt::unique(dofs); - // allocate list to renumber "dofs" - xt::xtensor renum = xt::empty({xt::amax(dofs)[0]+1}); - - // define renumbering - for ( size_t i = 0 ; i < unique.size() ; ++i ) renum[unique[i]] = i; + m_renum = xt::empty({n}); - return renum; + for (auto& j : unique) + { + m_renum(j) = i; + ++i; + } } // ------------------------------------------------------------------------------------------------- -inline xt::xtensor renumber(const xt::xtensor &dofs) +// apply renumbering, e.g. for a matrix: +// +// out(i,j) = renum(list(i,j)) + +template +T Renumber::apply(const T& list) const { - // list to renumber "dofs" - auto renum = renumber_index(dofs); + T out = T::from_shape(list.shape()); - // allocate reordered DOFs - xt::xtensor dofs_renumbered(dofs.shape()); + auto jt = out.begin(); - // iterator for loop below - auto jt = dofs_renumbered.begin(); + for ( auto it = list.begin() ; it != list.end() ; ++it, ++jt ) + *jt = m_renum(*it); - // loop to renumber: dofs_renumbered(i,j) = renum(dofs(i,j)) - for ( auto it = dofs.begin() ; it != dofs.end() ; ++it, ++jt ) - (*jt) = renum((*it)); + return out; +} + +// ------------------------------------------------------------------------------------------------- - return dofs_renumbered; +inline xt::xtensor Renumber::get(const xt::xtensor& dofs) const +{ + return this->apply(dofs); } // ------------------------------------------------------------------------------------------------- -inline xt::xtensor reorder_index(const xt::xtensor &dofs, - const xt::xtensor &iip, const std::string &location) +inline xt::xtensor Renumber::index() const { - // check "iip" to be a unique set - assert( xt::unique(iip).size() == iip.size() ); + return m_renum; +} - // get remaining DOFs - auto iiu = xt::setdiff1d(dofs, iip); +// ------------------------------------------------------------------------------------------------- - // get sizes - auto nnu = iiu.size(); - auto nnp = iip.size(); +inline Reorder::Reorder(const std::initializer_list> args) +{ + size_t n = 0; + size_t i = 0; + + for (auto& arg : args) + n = std::max(n, xt::amax(arg)[0]+1); + + #ifndef NDEBUG + for (auto& arg : args) + assert(xt::unique(arg) == xt::sort(arg)); + #endif + + m_renum = xt::empty({n}); + + for (auto& arg : args) + { + for (auto& j : arg) + { + m_renum(j) = i; + ++i; + } + } +} - // original set of DOFs - auto old = xt::unique(dofs); +// ------------------------------------------------------------------------------------------------- - // sanity check - assert( iiu.size() + iip.size() == xt::amax(dofs)[0]+1 ); +inline xt::xtensor Reorder::get(const xt::xtensor& dofs) const +{ + return this->apply(dofs); +} - // list to renumber "dofs" - // - allocate - xt::xtensor renum = xt::empty({xt::amax(dofs)[0]+1}); - // - fill - if ( location == "end" ) { - for ( size_t i = 0 ; i < iiu.size() ; ++i ) renum(iiu(i)) = i ; - for ( size_t i = 0 ; i < iip.size() ; ++i ) renum(iip(i)) = i+nnu; - } - else if ( location == "begin" or location == "beginning" ) { - for ( size_t i = 0 ; i < iip.size() ; ++i ) renum(iip(i)) = i ; - for ( size_t i = 0 ; i < iiu.size() ; ++i ) renum(iiu(i)) = i+nnp; - } - else { - throw std::runtime_error("Unknown reorder location '" + location + "'"); - } +// ------------------------------------------------------------------------------------------------- - return renum; +inline xt::xtensor Reorder::index() const +{ + return m_renum; } // ------------------------------------------------------------------------------------------------- -inline xt::xtensor reorder(const xt::xtensor &dofs, - const xt::xtensor &iip, const std::string &location) +// apply renumbering, e.g. for a matrix: +// +// out(i,j) = renum(list(i,j)) + +template +T Reorder::apply(const T& list) const { - // list to renumber "dofs" - auto renum = reorder_index(dofs, iip, location); + T out = T::from_shape(list.shape()); - // allocate reordered DOFs - xt::xtensor dofs_reordered(dofs.shape()); + auto jt = out.begin(); - // iterator for loop below - auto jt = dofs_reordered.begin(); + for ( auto it = list.begin() ; it != list.end() ; ++it, ++jt ) + *jt = m_renum(*it); - // loop to renumber: dofs_reordered(i,j) = renum(dofs(i,j)) - for ( auto it = dofs.begin() ; it != dofs.end() ; ++it, ++jt ) - *jt = renum(*it); + return out; +} - return dofs_reordered; +// ------------------------------------------------------------------------------------------------- + +inline xt::xtensor dofs(size_t nnode, size_t ndim) +{ + return xt::reshape_view(xt::arange(nnode*ndim),{nnode,ndim}); } // ------------------------------------------------------------------------------------------------- inline xt::xtensor coordination(const xt::xtensor &conn) { // get number of nodes size_t nnode = xt::amax(conn)[0] + 1; // number of elements connected to each node // - allocate xt::xtensor N = xt::zeros({nnode}); // - fill from connectivity for ( auto it = conn.begin(); it != conn.end(); ++it ) N(*it) += 1; return N; } // ------------------------------------------------------------------------------------------------- inline std::vector> elem2node(const xt::xtensor &conn) { // get coordination per node auto N = coordination(conn); // get number of nodes auto nnode = N.size(); // allocate std::vector> out; // reserve outer size out.resize(nnode); // reserve inner sizes for ( size_t i = 0 ; i < nnode ; ++i ) out[i].reserve(N(i)); // fill for ( size_t e = 0 ; e < conn.shape()[0] ; ++e ) for ( size_t m = 0 ; m < conn.shape()[1] ; ++m ) out[conn(e,m)].push_back(e); return out; } // ------------------------------------------------------------------------------------------------- +inline xt::xtensor renumber_index(const xt::xtensor &dofs) +{ + std::cout << "WARNING: 'GooseFEM::Mesh::renumber_index' is deprecated, use 'GooseFEM::Mesh::Renumber'" << std::endl; + + return Renumber(dofs).index(); +} + +// ------------------------------------------------------------------------------------------------- + +inline xt::xtensor renumber(const xt::xtensor &dofs) +{ + std::cout << "WARNING: 'GooseFEM::Mesh::renumber' is deprecated, use 'GooseFEM::Mesh::Renumber'" << std::endl; + + return Renumber(dofs).get(dofs); +} + +// ------------------------------------------------------------------------------------------------- + +inline xt::xtensor reorder_index(const xt::xtensor &dofs, + const xt::xtensor &iip, const std::string &location) +{ + std::cout << "WARNING: 'GooseFEM::Mesh::reorder_index' is deprecated, use 'GooseFEM::Mesh::Reorder'" << std::endl; + + if ( location == "end" ) + return Reorder({xt::setdiff1d(dofs,iip), iip}).index(); + else if ( location == "begin" or location == "beginning" ) + return Reorder({iip, xt::setdiff1d(dofs,iip)}).index(); + else + throw std::runtime_error("Unknown reorder location '" + location + "'"); +} + +// ------------------------------------------------------------------------------------------------- + +inline xt::xtensor reorder(const xt::xtensor &dofs, + const xt::xtensor &iip, const std::string &location) +{ + std::cout << "WARNING: 'GooseFEM::Mesh::reorder' is deprecated, use 'GooseFEM::Mesh::Reorder'" << std::endl; + + if ( location == "end" ) + return Reorder({xt::setdiff1d(dofs,iip), iip}).get(dofs); + else if ( location == "begin" or location == "beginning" ) + return Reorder({iip, xt::setdiff1d(dofs,iip)}).get(dofs); + else + throw std::runtime_error("Unknown reorder location '" + location + "'"); +} + +// ------------------------------------------------------------------------------------------------- + }} // namespace ... // ================================================================================================= #endif diff --git a/include/GooseFEM/VectorPartitioned.hpp b/include/GooseFEM/VectorPartitioned.hpp index 474af75..30225b7 100644 --- a/include/GooseFEM/VectorPartitioned.hpp +++ b/include/GooseFEM/VectorPartitioned.hpp @@ -1,749 +1,753 @@ /* ================================================================================================= (c - GPLv3) T.W.J. de Geus (Tom) | tom@geus.me | www.geus.me | github.com/tdegeus/GooseFEM ================================================================================================= */ #ifndef GOOSEFEM_VECTORPARTITIONED_HPP #define GOOSEFEM_VECTORPARTITIONED_HPP // ------------------------------------------------------------------------------------------------- #include "VectorPartitioned.h" // ================================================================================================= namespace GooseFEM { // ------------------------------------------------------------------------------------------------- -inline VectorPartitioned::VectorPartitioned(const xt::xtensor &conn, - const xt::xtensor &dofs, const xt::xtensor &iip) : - m_conn(conn), m_dofs(dofs), m_iip(iip) +inline VectorPartitioned::VectorPartitioned( + const xt::xtensor &conn, + const xt::xtensor &dofs, + const xt::xtensor &iip) : + m_conn(conn), + m_dofs(dofs), + m_iip(iip) { // mesh dimensions m_nelem = m_conn.shape()[0]; m_nne = m_conn.shape()[1]; m_nnode = m_dofs.shape()[0]; m_ndim = m_dofs.shape()[1]; // list with unknown DOFs m_iiu = xt::setdiff1d(dofs, iip); // dimensions of the system m_ndof = xt::amax(m_dofs)[0] + 1; m_nnp = m_iip.size(); m_nnu = m_iiu.size(); // DOFs per node, such that iiu = arange(nnu), iip = nnu + arange(nnp) m_part = Mesh::reorder(m_dofs, m_iip, "end"); // check consistency assert( xt::amax(m_conn)[0] + 1 == m_nnode ); assert( xt::amax(m_iip)[0] <= xt::amax(m_dofs)[0] ); assert( m_ndof <= m_nnode * m_ndim ); } // ------------------------------------------------------------------------------------------------- inline size_t VectorPartitioned::nelem() const { return m_nelem; } inline size_t VectorPartitioned::nne() const { return m_nne; } inline size_t VectorPartitioned::nnode() const { return m_nnode; } inline size_t VectorPartitioned::ndim() const { return m_ndim; } inline size_t VectorPartitioned::ndof() const { return m_ndof; } inline size_t VectorPartitioned::nnu() const { return m_nnu; } inline size_t VectorPartitioned::nnp() const { return m_nnp; } inline xt::xtensor VectorPartitioned::dofs() const { return m_dofs; } inline xt::xtensor VectorPartitioned::iiu() const { return m_iiu; } inline xt::xtensor VectorPartitioned::iip() const { return m_iip; } // ------------------------------------------------------------------------------------------------- inline void VectorPartitioned::copy(const xt::xtensor &nodevec_src, xt::xtensor &nodevec_dest) const { assert( nodevec_src .shape()[0] == m_nnode ); assert( nodevec_src .shape()[1] == m_ndim ); assert( nodevec_dest.shape()[0] == m_nnode ); assert( nodevec_dest.shape()[1] == m_ndim ); xt::noalias(nodevec_dest) = nodevec_src; } // ------------------------------------------------------------------------------------------------- inline void VectorPartitioned::copy_u(const xt::xtensor &nodevec_src, xt::xtensor &nodevec_dest) const { assert( nodevec_src .shape()[0] == m_nnode ); assert( nodevec_src .shape()[1] == m_ndim ); assert( nodevec_dest.shape()[0] == m_nnode ); assert( nodevec_dest.shape()[1] == m_ndim ); #pragma omp parallel for for ( size_t m = 0 ; m < m_nnode ; ++m ) for ( size_t i = 0 ; i < m_ndim ; ++i ) if ( m_part(m,i) < m_nnu ) nodevec_dest(m,i) = nodevec_src(m,i); } // ------------------------------------------------------------------------------------------------- inline void VectorPartitioned::copy_p(const xt::xtensor &nodevec_src, xt::xtensor &nodevec_dest) const { assert( nodevec_src .shape()[0] == m_nnode ); assert( nodevec_src .shape()[1] == m_ndim ); assert( nodevec_dest.shape()[0] == m_nnode ); assert( nodevec_dest.shape()[1] == m_ndim ); #pragma omp parallel for for ( size_t m = 0 ; m < m_nnode ; ++m ) for ( size_t i = 0 ; i < m_ndim ; ++i ) if ( m_part(m,i) >= m_nnu ) nodevec_dest(m,i) = nodevec_src(m,i); } // ------------------------------------------------------------------------------------------------- inline void VectorPartitioned::asDofs(const xt::xtensor &dofval_u, const xt::xtensor &dofval_p, xt::xtensor &dofval) const { assert( dofval_u.size() == m_nnu ); assert( dofval_p.size() == m_nnp ); assert( dofval.size() == m_ndof ); #pragma omp parallel for for ( size_t d = 0 ; d < m_nnu ; ++d ) dofval(m_iiu(d)) = dofval_u(d); #pragma omp parallel for for ( size_t d = 0 ; d < m_nnp ; ++d ) dofval(m_iip(d)) = dofval_p(d); } // ------------------------------------------------------------------------------------------------- inline void VectorPartitioned::asDofs(const xt::xtensor &nodevec, xt::xtensor &dofval) const { assert( nodevec.shape()[0] == m_nnode ); assert( nodevec.shape()[1] == m_ndim ); assert( dofval.size() == m_ndof ); #pragma omp parallel for for ( size_t m = 0 ; m < m_nnode ; ++m ) for ( size_t i = 0 ; i < m_ndim ; ++i ) dofval(m_dofs(m,i)) = nodevec(m,i); } // ------------------------------------------------------------------------------------------------- inline void VectorPartitioned::asDofs_u(const xt::xtensor &dofval, xt::xtensor &dofval_u) const { assert( dofval.size() == m_ndof ); assert( dofval_u.size() == m_nnu ); #pragma omp parallel for for ( size_t d = 0 ; d < m_nnu ; ++d ) dofval_u(d) = dofval(m_iiu(d)); } // ------------------------------------------------------------------------------------------------- inline void VectorPartitioned::asDofs_u(const xt::xtensor &nodevec, xt::xtensor &dofval_u) const { assert( nodevec.shape()[0] == m_nnode ); assert( nodevec.shape()[1] == m_ndim ); assert( dofval_u.size() == m_nnu ); #pragma omp parallel for for ( size_t m = 0 ; m < m_nnode ; ++m ) for ( size_t i = 0 ; i < m_ndim ; ++i ) if ( m_part(m,i) < m_nnu ) dofval_u(m_part(m,i)) = nodevec(m,i); } // ------------------------------------------------------------------------------------------------- inline void VectorPartitioned::asDofs_p(const xt::xtensor &dofval, xt::xtensor &dofval_p) const { assert( dofval.size() == m_ndof ); assert( dofval_p.size() == m_nnp ); #pragma omp parallel for for ( size_t d = 0 ; d < m_nnp ; ++d ) dofval_p(d) = dofval(m_iip(d)); } // ------------------------------------------------------------------------------------------------- inline void VectorPartitioned::asDofs_p(const xt::xtensor &nodevec, xt::xtensor &dofval_p) const { assert( nodevec.shape()[0] == m_nnode ); assert( nodevec.shape()[1] == m_ndim ); assert( dofval_p.size() == m_nnp ); #pragma omp parallel for for ( size_t m = 0 ; m < m_nnode ; ++m ) for ( size_t i = 0 ; i < m_ndim ; ++i ) if ( m_part(m,i) >= m_nnu ) dofval_p(m_part(m,i)-m_nnu) = nodevec(m,i); } // ------------------------------------------------------------------------------------------------- inline void VectorPartitioned::asDofs(const xt::xtensor &elemvec, xt::xtensor &dofval) const { assert( elemvec.shape()[0] == m_nelem ); assert( elemvec.shape()[1] == m_nne ); assert( elemvec.shape()[2] == m_ndim ); assert( dofval.size() == m_ndof ); #pragma omp parallel for for ( size_t e = 0 ; e < m_nelem ; ++e ) for ( size_t m = 0 ; m < m_nne ; ++m ) for ( size_t i = 0 ; i < m_ndim ; ++i ) dofval(m_dofs(m_conn(e,m),i)) = elemvec(e,m,i); } // ------------------------------------------------------------------------------------------------- inline void VectorPartitioned::asDofs_u(const xt::xtensor &elemvec, xt::xtensor &dofval_u) const { assert( elemvec.shape()[0] == m_nelem ); assert( elemvec.shape()[1] == m_nne ); assert( elemvec.shape()[2] == m_ndim ); assert( dofval_u.size() == m_nnu ); #pragma omp parallel for for ( size_t e = 0 ; e < m_nelem ; ++e ) for ( size_t m = 0 ; m < m_nne ; ++m ) for ( size_t i = 0 ; i < m_ndim ; ++i ) if ( m_part(m_conn(e,m),i) < m_nnu ) dofval_u(m_part(m_conn(e,m),i)) = elemvec(e,m,i); } // ------------------------------------------------------------------------------------------------- inline void VectorPartitioned::asDofs_p(const xt::xtensor &elemvec, xt::xtensor &dofval_p) const { assert( elemvec.shape()[0] == m_nelem ); assert( elemvec.shape()[1] == m_nne ); assert( elemvec.shape()[2] == m_ndim ); assert( dofval_p.size() == m_nnp ); #pragma omp parallel for for ( size_t e = 0 ; e < m_nelem ; ++e ) for ( size_t m = 0 ; m < m_nne ; ++m ) for ( size_t i = 0 ; i < m_ndim ; ++i ) if ( m_part(m_conn(e,m),i) >= m_nnu ) dofval_p(m_part(m_conn(e,m),i)-m_nnu) = elemvec(e,m,i); } // ------------------------------------------------------------------------------------------------- inline void VectorPartitioned::asNode(const xt::xtensor &dofval, xt::xtensor &nodevec) const { assert( dofval.size() == m_ndof ); assert( nodevec.shape()[0] == m_nnode ); assert( nodevec.shape()[1] == m_ndim ); #pragma omp parallel for for ( size_t m = 0 ; m < m_nnode ; ++m ) for ( size_t i = 0 ; i < m_ndim ; ++i ) nodevec(m,i) = dofval(m_dofs(m,i)); } // ------------------------------------------------------------------------------------------------- inline void VectorPartitioned::asNode(const xt::xtensor &dofval_u, const xt::xtensor &dofval_p, xt::xtensor &nodevec) const { assert( dofval_u.size() == m_nnu ); assert( dofval_p.size() == m_nnp ); assert( nodevec.shape()[0] == m_nnode ); assert( nodevec.shape()[1] == m_ndim ); #pragma omp parallel for for ( size_t m = 0 ; m < m_nnode ; ++m ) { for ( size_t i = 0 ; i < m_ndim ; ++i ) { if ( m_part(m,i) < m_nnu ) nodevec(m,i) = dofval_u(m_part(m,i) ); else nodevec(m,i) = dofval_p(m_part(m,i)-m_nnu); } } } // ------------------------------------------------------------------------------------------------- inline void VectorPartitioned::asNode(const xt::xtensor &elemvec, xt::xtensor &nodevec) const { assert( elemvec.shape()[0] == m_nelem ); assert( elemvec.shape()[1] == m_nne ); assert( elemvec.shape()[2] == m_ndim ); assert( nodevec.shape()[0] == m_nnode ); assert( nodevec.shape()[1] == m_ndim ); #pragma omp parallel for for ( size_t e = 0 ; e < m_nelem ; ++e ) for ( size_t m = 0 ; m < m_nne ; ++m ) for ( size_t i = 0 ; i < m_ndim ; ++i ) nodevec(m_conn(e,m),i) = elemvec(e,m,i); } // ------------------------------------------------------------------------------------------------- inline void VectorPartitioned::asElement(const xt::xtensor &dofval, xt::xtensor &elemvec) const { assert( dofval.size() == m_ndof ); assert( elemvec.shape()[0] == m_nelem ); assert( elemvec.shape()[1] == m_nne ); assert( elemvec.shape()[2] == m_ndim ); #pragma omp parallel for for ( size_t e = 0 ; e < m_nelem ; ++e ) for ( size_t m = 0 ; m < m_nne ; ++m ) for ( size_t i = 0 ; i < m_ndim ; ++i ) elemvec(e,m,i) = dofval(m_dofs(m_conn(e,m),i)); } // ------------------------------------------------------------------------------------------------- inline void VectorPartitioned::asElement(const xt::xtensor &dofval_u, const xt::xtensor &dofval_p, xt::xtensor &elemvec) const { assert( dofval_u.size() == m_nnu ); assert( dofval_p.size() == m_nnp ); assert( elemvec.shape()[0] == m_nelem ); assert( elemvec.shape()[1] == m_nne ); assert( elemvec.shape()[2] == m_ndim ); #pragma omp parallel for for ( size_t e = 0 ; e < m_nelem ; ++e ) { for ( size_t m = 0 ; m < m_nne ; ++m ) { for ( size_t i = 0 ; i < m_ndim ; ++i ) { if ( m_part(m_conn(e,m),i) &nodevec, xt::xtensor &elemvec) const { assert( nodevec.shape()[0] == m_nnode ); assert( nodevec.shape()[1] == m_ndim ); assert( elemvec.shape()[0] == m_nelem ); assert( elemvec.shape()[1] == m_nne ); assert( elemvec.shape()[2] == m_ndim ); #pragma omp parallel for for ( size_t e = 0 ; e < m_nelem ; ++e ) for ( size_t m = 0 ; m < m_nne ; ++m ) for ( size_t i = 0 ; i < m_ndim ; ++i ) elemvec(e,m,i) = nodevec(m_conn(e,m),i); } // ------------------------------------------------------------------------------------------------- inline void VectorPartitioned::assembleDofs(const xt::xtensor &nodevec, xt::xtensor &dofval) const { assert( nodevec.shape()[0] == m_nnode ); assert( nodevec.shape()[1] == m_ndim ); assert( dofval.size() == m_ndof ); dofval.fill(0.0); for ( size_t m = 0 ; m < m_nnode ; ++m ) for ( size_t i = 0 ; i < m_ndim ; ++i ) dofval(m_dofs(m,i)) += nodevec(m,i); } // ------------------------------------------------------------------------------------------------- inline void VectorPartitioned::assembleDofs_u(const xt::xtensor &nodevec, xt::xtensor &dofval_u) const { assert( nodevec.shape()[0] == m_nnode ); assert( nodevec.shape()[1] == m_ndim ); assert( dofval_u.size() == m_nnu ); dofval_u.fill(0.0); for ( size_t m = 0 ; m < m_nnode ; ++m ) for ( size_t i = 0 ; i < m_ndim ; ++i ) if ( m_part(m,i) < m_nnu ) dofval_u(m_part(m,i)) += nodevec(m,i); } // ------------------------------------------------------------------------------------------------- inline void VectorPartitioned::assembleDofs_p(const xt::xtensor &nodevec, xt::xtensor &dofval_p) const { assert( nodevec.shape()[0] == m_nnode ); assert( nodevec.shape()[1] == m_ndim ); assert( dofval_p.size() == m_nnp ); dofval_p.fill(0.0); for ( size_t m = 0 ; m < m_nnode ; ++m ) for ( size_t i = 0 ; i < m_ndim ; ++i ) if ( m_part(m,i) >= m_nnu ) dofval_p(m_part(m,i)-m_nnu) += nodevec(m,i); } // ------------------------------------------------------------------------------------------------- inline void VectorPartitioned::assembleDofs(const xt::xtensor &elemvec, xt::xtensor &dofval) const { assert( elemvec.shape()[0] == m_nelem ); assert( elemvec.shape()[1] == m_nne ); assert( elemvec.shape()[2] == m_ndim ); assert( dofval.size() == m_ndof ); dofval.fill(0.0); for ( size_t e = 0 ; e < m_nelem ; ++e ) for ( size_t m = 0 ; m < m_nne ; ++m ) for ( size_t i = 0 ; i < m_ndim ; ++i ) dofval(m_dofs(m_conn(e,m),i)) += elemvec(e,m,i); } // ------------------------------------------------------------------------------------------------- inline void VectorPartitioned::assembleDofs_u(const xt::xtensor &elemvec, xt::xtensor &dofval_u) const { assert( elemvec.shape()[0] == m_nelem ); assert( elemvec.shape()[1] == m_nne ); assert( elemvec.shape()[2] == m_ndim ); assert( dofval_u.size() == m_nnu ); dofval_u.fill(0.0); for ( size_t e = 0 ; e < m_nelem ; ++e ) for ( size_t m = 0 ; m < m_nne ; ++m ) for ( size_t i = 0 ; i < m_ndim ; ++i ) if ( m_part(m_conn(e,m),i) < m_nnu ) dofval_u(m_part(m_conn(e,m),i)) += elemvec(e,m,i); } // ------------------------------------------------------------------------------------------------- inline void VectorPartitioned::assembleDofs_p(const xt::xtensor &elemvec, xt::xtensor &dofval_p) const { assert( elemvec.shape()[0] == m_nelem ); assert( elemvec.shape()[1] == m_nne ); assert( elemvec.shape()[2] == m_ndim ); assert( dofval_p.size() == m_nnp ); dofval_p.fill(0.0); for ( size_t e = 0 ; e < m_nelem ; ++e ) for ( size_t m = 0 ; m < m_nne ; ++m ) for ( size_t i = 0 ; i < m_ndim ; ++i ) if ( m_part(m_conn(e,m),i) >= m_nnu ) dofval_p(m_part(m_conn(e,m),i)-m_nnu) += elemvec(e,m,i); } // ------------------------------------------------------------------------------------------------- inline void VectorPartitioned::assembleNode(const xt::xtensor &elemvec, xt::xtensor &nodevec) const { assert( elemvec.shape()[0] == m_nelem ); assert( elemvec.shape()[1] == m_nne ); assert( elemvec.shape()[2] == m_ndim ); assert( nodevec.shape()[0] == m_nnode ); assert( nodevec.shape()[1] == m_ndim ); // assemble to DOFs xt::xtensor dofval = this->assembleDofs(elemvec); // read from DOFs this->asNode(dofval, nodevec); } // ------------------------------------------------------------------------------------------------- inline xt::xtensor VectorPartitioned::asDofs(const xt::xtensor &dofval_u, const xt::xtensor &dofval_p) const { xt::xtensor dofval = xt::empty({m_ndof}); this->asDofs(dofval_u, dofval_p, dofval); return dofval; } // ------------------------------------------------------------------------------------------------- inline xt::xtensor VectorPartitioned::asDofs(const xt::xtensor &nodevec) const { xt::xtensor dofval = xt::empty({m_ndof}); this->asDofs(nodevec, dofval); return dofval; } // ------------------------------------------------------------------------------------------------- inline xt::xtensor VectorPartitioned::asDofs_u(const xt::xtensor &dofval) const { xt::xtensor dofval_u = xt::empty({m_nnu}); this->asDofs_u(dofval, dofval_u); return dofval_u; } // ------------------------------------------------------------------------------------------------- inline xt::xtensor VectorPartitioned::asDofs_u(const xt::xtensor &nodevec) const { xt::xtensor dofval_u = xt::empty({m_nnu}); this->asDofs_u(nodevec, dofval_u); return dofval_u; } // ------------------------------------------------------------------------------------------------- inline xt::xtensor VectorPartitioned::asDofs_p(const xt::xtensor &dofval) const { xt::xtensor dofval_p = xt::empty({m_nnp}); this->asDofs_p(dofval, dofval_p); return dofval_p; } // ------------------------------------------------------------------------------------------------- inline xt::xtensor VectorPartitioned::asDofs_p(const xt::xtensor &nodevec) const { xt::xtensor dofval_p = xt::empty({m_nnp}); this->asDofs_p(nodevec, dofval_p); return dofval_p; } // ------------------------------------------------------------------------------------------------- inline xt::xtensor VectorPartitioned::asDofs(const xt::xtensor &elemvec) const { xt::xtensor dofval = xt::empty({m_ndof}); this->asDofs(elemvec, dofval); return dofval; } // ------------------------------------------------------------------------------------------------- inline xt::xtensor VectorPartitioned::asDofs_u(const xt::xtensor &elemvec) const { xt::xtensor dofval_u = xt::empty({m_nnu}); this->asDofs_u(elemvec, dofval_u); return dofval_u; } // ------------------------------------------------------------------------------------------------- inline xt::xtensor VectorPartitioned::asDofs_p(const xt::xtensor &elemvec) const { xt::xtensor dofval_p = xt::empty({m_nnp}); this->asDofs_p(elemvec, dofval_p); return dofval_p; } // ------------------------------------------------------------------------------------------------- inline xt::xtensor VectorPartitioned::asNode(const xt::xtensor &dofval) const { xt::xtensor nodevec = xt::empty({m_nnode, m_ndim}); this->asNode(dofval, nodevec); return nodevec; } // ------------------------------------------------------------------------------------------------- inline xt::xtensor VectorPartitioned::asNode(const xt::xtensor &dofval_u, const xt::xtensor &dofval_p) const { xt::xtensor nodevec = xt::empty({m_nnode, m_ndim}); this->asNode(dofval_u, dofval_p, nodevec); return nodevec; } // ------------------------------------------------------------------------------------------------- inline xt::xtensor VectorPartitioned::asNode(const xt::xtensor &elemvec) const { xt::xtensor nodevec = xt::empty({m_nnode, m_ndim}); this->asNode(elemvec, nodevec); return nodevec; } // ------------------------------------------------------------------------------------------------- inline xt::xtensor VectorPartitioned::asElement(const xt::xtensor &dofval) const { xt::xtensor elemvec = xt::empty({m_nelem, m_nne, m_ndim}); this->asElement(dofval, elemvec); return elemvec; } // ------------------------------------------------------------------------------------------------- inline xt::xtensor VectorPartitioned::asElement(const xt::xtensor &dofval_u, const xt::xtensor &dofval_p) const { xt::xtensor elemvec = xt::empty({m_nelem, m_nne, m_ndim}); this->asElement(dofval_u, dofval_p, elemvec); return elemvec; } // ------------------------------------------------------------------------------------------------- inline xt::xtensor VectorPartitioned::asElement(const xt::xtensor &nodevec) const { xt::xtensor elemvec = xt::empty({m_nelem, m_nne, m_ndim}); this->asElement(nodevec, elemvec); return elemvec; } // ------------------------------------------------------------------------------------------------- inline xt::xtensor VectorPartitioned::assembleDofs( const xt::xtensor &nodevec) const { xt::xtensor dofval = xt::empty({m_ndof}); this->assembleDofs(nodevec, dofval); return dofval; } // ------------------------------------------------------------------------------------------------- inline xt::xtensor VectorPartitioned::assembleDofs_u( const xt::xtensor &nodevec) const { xt::xtensor dofval_u = xt::empty({m_nnu}); this->assembleDofs_u(nodevec, dofval_u); return dofval_u; } // ------------------------------------------------------------------------------------------------- inline xt::xtensor VectorPartitioned::assembleDofs_p( const xt::xtensor &nodevec) const { xt::xtensor dofval_p = xt::empty({m_nnp}); this->assembleDofs_p(nodevec, dofval_p); return dofval_p; } // ------------------------------------------------------------------------------------------------- inline xt::xtensor VectorPartitioned::assembleDofs( const xt::xtensor &elemvec) const { xt::xtensor dofval = xt::empty({m_ndof}); this->assembleDofs(elemvec, dofval); return dofval; } // ------------------------------------------------------------------------------------------------- inline xt::xtensor VectorPartitioned::assembleDofs_u( const xt::xtensor &elemvec) const { xt::xtensor dofval_u = xt::empty({m_nnu}); this->assembleDofs_u(elemvec, dofval_u); return dofval_u; } // ------------------------------------------------------------------------------------------------- inline xt::xtensor VectorPartitioned::assembleDofs_p( const xt::xtensor &elemvec) const { xt::xtensor dofval_p = xt::empty({m_nnp}); this->assembleDofs_p(elemvec, dofval_p); return dofval_p; } // ------------------------------------------------------------------------------------------------- inline xt::xtensor VectorPartitioned::assembleNode( const xt::xtensor &elemvec) const { xt::xtensor nodevec = xt::empty({m_nnode, m_ndim}); this->assembleNode(elemvec, nodevec); return nodevec; } // ------------------------------------------------------------------------------------------------- } // namespace ... // ================================================================================================= #endif diff --git a/include/GooseFEM/python.cpp b/include/GooseFEM/python.cpp deleted file mode 100644 index 257287a..0000000 --- a/include/GooseFEM/python.cpp +++ /dev/null @@ -1,727 +0,0 @@ -/* ================================================================================================= - -(c - GPLv3) T.W.J. de Geus (Tom) | tom@geus.me | www.geus.me | github.com/tdegeus/GooseFEM - -================================================================================================= */ - -#include - -#include -#include - -#include - -#include - -#include "GooseFEM.h" - -// ================================================================================================= - -namespace py = pybind11; -namespace M = GooseFEM; - -// ================================================================================================= - -PYBIND11_MODULE(GooseFEM, m) { - -m.doc() = "Some simple finite element meshes and operations"; - -// ================================================================================================= - -py::class_(m, "Vector") - - .def(py::init &, const xt::xtensor &>(), "Switch between dofval/nodevec/elemvec", py::arg("conn"), py::arg("dofs")) - - .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("dofs" , &M::Vector::dofs , "Return degrees-of-freedom") - - .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("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&>(&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("assembleNode", py::overload_cast&>(&M::Vector::assembleNode, py::const_), "Assemble 'nodevec'", py::arg("elemvec")) - - .def("__repr__", [](const GooseFEM::Vector &){ return ""; }); - -// ================================================================================================= - -py::class_(m, "VectorPartitioned") - - .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::VectorPartitioned::nelem, "Return number of element") - .def("nne" , &M::VectorPartitioned::nne , "Return number of nodes per element") - .def("nnode", &M::VectorPartitioned::nnode, "Return number of nodes") - .def("ndim" , &M::VectorPartitioned::ndim , "Return number of dimensions") - .def("ndof" , &M::VectorPartitioned::ndof , "Return number of degrees-of-freedom") - .def("nnu" , &M::VectorPartitioned::nnu , "Return number of unknown degrees-of-freedom") - .def("nnp" , &M::VectorPartitioned::nnp , "Return number of prescribed degrees-of-freedom") - - .def("dofs" , &M::VectorPartitioned::dofs , "Return degrees-of-freedom") - .def("iiu" , &M::VectorPartitioned::iiu , "Return unknown degrees-of-freedom") - .def("iip" , &M::VectorPartitioned::iip , "Return prescribed degrees-of-freedom") - - .def("asDofs" , py::overload_cast&,const xt::xtensor&>(&M::VectorPartitioned::asDofs , py::const_), "Set 'dofval" , py::arg("dofval_u"), py::arg("dofval_p")) - .def("asDofs" , py::overload_cast& >(&M::VectorPartitioned::asDofs , py::const_), "Set 'dofval" , py::arg("nodevec")) - .def("asDofs" , py::overload_cast& >(&M::VectorPartitioned::asDofs , py::const_), "Set 'dofval" , py::arg("elemvec")) - .def("asDofs_u" , py::overload_cast& >(&M::VectorPartitioned::asDofs_u , py::const_), "Set 'dofval" , py::arg("nodevec")) - .def("asDofs_u" , py::overload_cast& >(&M::VectorPartitioned::asDofs_u , py::const_), "Set 'dofval" , py::arg("elemvec")) - .def("asDofs_p" , py::overload_cast& >(&M::VectorPartitioned::asDofs_p , py::const_), "Set 'dofval" , py::arg("nodevec")) - .def("asDofs_p" , py::overload_cast& >(&M::VectorPartitioned::asDofs_p , py::const_), "Set 'dofval" , py::arg("elemvec")) - - .def("asNode" , py::overload_cast&,const xt::xtensor&>(&M::VectorPartitioned::asNode , py::const_), "Set 'nodevec", py::arg("dofval_u"), py::arg("dofval_p")) - .def("asNode" , py::overload_cast& >(&M::VectorPartitioned::asNode , py::const_), "Set 'nodevec", py::arg("dofval")) - .def("asNode" , py::overload_cast& >(&M::VectorPartitioned::asNode , py::const_), "Set 'nodevec", py::arg("elemvec")) - - .def("asElement", py::overload_cast&,const xt::xtensor&>(&M::VectorPartitioned::asElement, py::const_), "Set 'elemvec", py::arg("dofval_u"), py::arg("dofval_p")) - .def("asElement", py::overload_cast& >(&M::VectorPartitioned::asElement, py::const_), "Set 'elemvec", py::arg("dofval")) - .def("asElement", py::overload_cast& >(&M::VectorPartitioned::asElement, py::const_), "Set 'elemvec", py::arg("nodevec")) - - .def("assembleDofs" , py::overload_cast&>(&M::VectorPartitioned::assembleDofs , py::const_), "Assemble 'dofval'" , py::arg("nodevec")) - .def("assembleDofs" , py::overload_cast&>(&M::VectorPartitioned::assembleDofs , py::const_), "Assemble 'dofval'" , py::arg("elemvec")) - .def("assembleDofs_u", py::overload_cast&>(&M::VectorPartitioned::assembleDofs_u, py::const_), "Assemble 'dofval'" , py::arg("nodevec")) - .def("assembleDofs_u", py::overload_cast&>(&M::VectorPartitioned::assembleDofs_u, py::const_), "Assemble 'dofval'" , py::arg("elemvec")) - .def("assembleDofs_p", py::overload_cast&>(&M::VectorPartitioned::assembleDofs_p, py::const_), "Assemble 'dofval'" , py::arg("nodevec")) - .def("assembleDofs_p", py::overload_cast&>(&M::VectorPartitioned::assembleDofs_p, py::const_), "Assemble 'dofval'" , py::arg("elemvec")) - - .def("assembleNode" , py::overload_cast&>(&M::VectorPartitioned::assembleNode , py::const_), "Assemble 'nodevec'", py::arg("elemvec")) - - .def("__repr__", [](const GooseFEM::VectorPartitioned &){ return ""; }); - -// ================================================================================================= - -py::class_(m, "MatrixDiagonalPartitioned") - - .def(py::init &, const xt::xtensor &, const xt::xtensor &>(), "Diagonal matrix", py::arg("conn"), py::arg("dofs"), py::arg("iip")) - - .def("nelem", &M::MatrixDiagonalPartitioned::nelem, "Return number of element") - .def("nne" , &M::MatrixDiagonalPartitioned::nne , "Return number of nodes per element") - .def("nnode", &M::MatrixDiagonalPartitioned::nnode, "Return number of nodes") - .def("ndim" , &M::MatrixDiagonalPartitioned::ndim , "Return number of dimensions") - .def("ndof" , &M::MatrixDiagonalPartitioned::ndof , "Return number of degrees-of-freedom") - .def("nnu" , &M::MatrixDiagonalPartitioned::nnu , "Return number of unknown degrees-of-freedom") - .def("nnp" , &M::MatrixDiagonalPartitioned::nnp , "Return number of prescribed degrees-of-freedom") - - .def("assemble", &M::MatrixDiagonalPartitioned::assemble, "Assemble matrix from 'elemmat", py::arg("elemmat")) - - .def("dofs" , &M::MatrixDiagonalPartitioned::dofs , "Return degrees-of-freedom") - .def("iiu" , &M::MatrixDiagonalPartitioned::iiu , "Return unknown degrees-of-freedom") - .def("iip" , &M::MatrixDiagonalPartitioned::iip , "Return prescribed degrees-of-freedom") - - .def("dot" , py::overload_cast& >(&M::MatrixDiagonalPartitioned::dot , py::const_), "Dot product 'b_i = A_ij * x_j" , py::arg("x")) - .def("dot_u", py::overload_cast&, const xt::xtensor&>(&M::MatrixDiagonalPartitioned::dot_u, py::const_), "Dot product 'b_i = A_ij * x_j (b_u = A_uu * x_u + A_up * x_p == A_uu * x_u)", py::arg("x_u"), py::arg("x_p")) - .def("dot_p", py::overload_cast&, const xt::xtensor&>(&M::MatrixDiagonalPartitioned::dot_p, py::const_), "Dot product 'b_i = A_ij * x_j (b_p = A_pu * x_u + A_pp * x_p == A_pp * x_p)", py::arg("x_u"), py::arg("x_p")) - - // .def("solve_u", &M::MatrixDiagonalPartitioned::solve_u, "Solve 'x_u = A_uu \\ ( b_u - A_up * x_p ) == A_uu \\ b_u'", py::arg("b_u"), py::arg("x_p")) - - .def("asDiagonal", &M::MatrixDiagonalPartitioned::asDiagonal, "Return as diagonal matrix (column)") - - .def("__repr__", [](const GooseFEM::MatrixDiagonalPartitioned &){ return ""; }); - -// ================================================================================================= - -py::module mElement = m.def_submodule("Element", "Generic element routines"); - -// ------------------------------------------------------------------------------------------------- - -mElement.def("asElementVector" , &GooseFEM::Element::asElementVector , "Covert to 'elemvec'", py::arg("conn"), py::arg("nodevec")); -mElement.def("assembleElementVector", &GooseFEM::Element::assembleNodeVector, "Assemble 'nodevec'" , py::arg("conn"), py::arg("elemvec")); - -// ================================================================================================= - -{ - -py::module sm = mElement.def_submodule("Quad4", "Linear quadrilateral elements (2D)"); - -// ------------------------------------------------------------------------------------------------- - -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", &GooseFEM::Element::Quad4::Quadrature::nelem, "Return number of elements" ) - .def("nne" , &GooseFEM::Element::Quad4::Quadrature::nne , "Return number of nodes per element" ) - .def("ndim" , &GooseFEM::Element::Quad4::Quadrature::ndim , "Return number of dimensions" ) - .def("nip" , &GooseFEM::Element::Quad4::Quadrature::nip , "Return number of integration points") - - .def("dV" , py::overload_cast<>(&GooseFEM::Element::Quad4::Quadrature::dV , py::const_), "Integration point volume (qscalar)") - .def("dVtensor", py::overload_cast<>(&GooseFEM::Element::Quad4::Quadrature::dVtensor, py::const_), "Integration point volume (qtensor)") - - .def("gradN_vector" , py::overload_cast &>(&GooseFEM::Element::Quad4::Quadrature::gradN_vector , py::const_), "Dyadic product, returns 'qtensor'", py::arg("elemvec")) - .def("gradN_vector_T" , py::overload_cast &>(&GooseFEM::Element::Quad4::Quadrature::gradN_vector_T , py::const_), "Dyadic product, returns 'qtensor'", py::arg("elemvec")) - .def("symGradN_vector", py::overload_cast &>(&GooseFEM::Element::Quad4::Quadrature::symGradN_vector, py::const_), "Dyadic product, returns 'qtensor'", py::arg("elemvec")) - - .def("int_N_scalar_NT_dV" , py::overload_cast &>(&GooseFEM::Element::Quad4::Quadrature::int_N_scalar_NT_dV , py::const_), "Integration, returns 'elemmat'", py::arg("qscalar")) - .def("int_gradN_dot_tensor2_dV", py::overload_cast &>(&GooseFEM::Element::Quad4::Quadrature::int_gradN_dot_tensor2_dV, py::const_), "Integration, returns 'elemvec'", py::arg("qtensor")) - - .def("__repr__", [](const GooseFEM::Element::Quad4::Quadrature &){ return ""; }); - -// ------------------------------------------------------------------------------------------------- - -{ - -py::module ssm = sm.def_submodule("Gauss", "Gauss quadrature"); - -ssm.def("nip", &GooseFEM::Element::Quad4::Gauss::nip, "Return number of integration point" ); -ssm.def("xi" , &GooseFEM::Element::Quad4::Gauss::xi , "Return integration point coordinates"); -ssm.def("w" , &GooseFEM::Element::Quad4::Gauss::w , "Return integration point weights" ); - -} - -// ------------------------------------------------------------------------------------------------- - -{ - -py::module ssm = sm.def_submodule("Nodal", "Nodal quadrature"); - -ssm.def("nip", &GooseFEM::Element::Quad4::Nodal::nip, "Return number of integration point" ); -ssm.def("xi" , &GooseFEM::Element::Quad4::Nodal::xi , "Return integration point coordinates"); -ssm.def("w" , &GooseFEM::Element::Quad4::Nodal::w , "Return integration point weights" ); - -} - -// ------------------------------------------------------------------------------------------------- - -} - -// ================================================================================================= - -{ - -py::module sm = mElement.def_submodule("Hex8", "Linear hexahedron (brick) elements (3D)"); - -// ------------------------------------------------------------------------------------------------- - -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", &GooseFEM::Element::Hex8::Quadrature::nelem, "Return number of elements" ) - .def("nne" , &GooseFEM::Element::Hex8::Quadrature::nne , "Return number of nodes per element" ) - .def("ndim" , &GooseFEM::Element::Hex8::Quadrature::ndim , "Return number of dimensions" ) - .def("nip" , &GooseFEM::Element::Hex8::Quadrature::nip , "Return number of integration points") - - .def("dV" , py::overload_cast<>(&GooseFEM::Element::Hex8::Quadrature::dV , py::const_), "Integration point volume (qscalar)") - .def("dVtensor", py::overload_cast<>(&GooseFEM::Element::Hex8::Quadrature::dVtensor, py::const_), "Integration point volume (qtensor)") - - .def("gradN_vector" , py::overload_cast &>(&GooseFEM::Element::Hex8::Quadrature::gradN_vector , py::const_), "Dyadic product, returns 'qtensor'", py::arg("elemvec")) - .def("gradN_vector_T" , py::overload_cast &>(&GooseFEM::Element::Hex8::Quadrature::gradN_vector_T , py::const_), "Dyadic product, returns 'qtensor'", py::arg("elemvec")) - .def("symGradN_vector", py::overload_cast &>(&GooseFEM::Element::Hex8::Quadrature::symGradN_vector, py::const_), "Dyadic product, returns 'qtensor'", py::arg("elemvec")) - - .def("int_N_scalar_NT_dV" , py::overload_cast &>(&GooseFEM::Element::Hex8::Quadrature::int_N_scalar_NT_dV , py::const_), "Integration, returns 'elemmat'", py::arg("qscalar")) - .def("int_gradN_dot_tensor2_dV", py::overload_cast &>(&GooseFEM::Element::Hex8::Quadrature::int_gradN_dot_tensor2_dV, py::const_), "Integration, returns 'elemvec'", py::arg("qtensor")) - - .def("__repr__", [](const GooseFEM::Element::Hex8::Quadrature &){ return ""; }); - -// ------------------------------------------------------------------------------------------------- - -{ - -py::module ssm = sm.def_submodule("Gauss", "Gauss quadrature"); - -ssm.def("nip", &GooseFEM::Element::Hex8::Gauss::nip, "Return number of integration point" ); -ssm.def("xi" , &GooseFEM::Element::Hex8::Gauss::xi , "Return integration point coordinates"); -ssm.def("w" , &GooseFEM::Element::Hex8::Gauss::w , "Return integration point weights" ); - -} - -// ------------------------------------------------------------------------------------------------- - -{ - -py::module ssm = sm.def_submodule("Nodal", "Nodal quadrature"); - -ssm.def("nip", &GooseFEM::Element::Hex8::Nodal::nip, "Return number of integration point" ); -ssm.def("xi" , &GooseFEM::Element::Hex8::Nodal::xi , "Return integration point coordinates"); -ssm.def("w" , &GooseFEM::Element::Hex8::Nodal::w , "Return integration point weights" ); - -} - -// ------------------------------------------------------------------------------------------------- - -} - -// ================================================================================================= - -py::module mMesh = m.def_submodule("Mesh", "Generic mesh routines"); - -// ------------------------------------------------------------------------------------------------- - -mMesh.def("dofs", &GooseFEM::Mesh::dofs, "List with DOF-numbers (in sequential order)", py::arg("nnode"), py::arg("ndim")); - -mMesh.def("renumber", &GooseFEM::Mesh::renumber, "Renumber DOF-list to use the lowest possible index", py::arg("dofs")); - -mMesh.def("renumber_index", &GooseFEM::Mesh::renumber_index, "Index-list to renumber", py::arg("dofs")); - -mMesh.def("reorder", &GooseFEM::Mesh::reorder, "Renumber DOF-list to begin or end with 'idx'", py::arg("dofs"), py::arg("idx"), py::arg("location")="end"); - -mMesh.def("reorder_index", &GooseFEM::Mesh::reorder_index, "Index-list to reorder", py::arg("dofs"), py::arg("idx"), py::arg("location")="end"); - -mMesh.def("coordination", &GooseFEM::Mesh::coordination, "Coordination number of each node", py::arg("conn")); - -mMesh.def("elem2node", &GooseFEM::Mesh::elem2node, "Elements connect to each node", py::arg("conn")); - -// ================================================================================================= - -{ - -py::module sm = mMesh.def_submodule("Hex8", "Linear hexahedron (brick) elements (3D)"); - -// ------------------------------------------------------------------------------------------------- - -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" , &GooseFEM::Mesh::Hex8::Regular::nelem ) - .def("nnode" , &GooseFEM::Mesh::Hex8::Regular::nnode ) - .def("nne" , &GooseFEM::Mesh::Hex8::Regular::nne ) - .def("ndim" , &GooseFEM::Mesh::Hex8::Regular::ndim ) - - .def("coor" , &GooseFEM::Mesh::Hex8::Regular::coor ) - .def("conn" , &GooseFEM::Mesh::Hex8::Regular::conn ) - - .def("nodesFront" , &GooseFEM::Mesh::Hex8::Regular::nodesFront ) - .def("nodesBack" , &GooseFEM::Mesh::Hex8::Regular::nodesBack ) - .def("nodesLeft" , &GooseFEM::Mesh::Hex8::Regular::nodesLeft ) - .def("nodesRight" , &GooseFEM::Mesh::Hex8::Regular::nodesRight ) - .def("nodesBottom" , &GooseFEM::Mesh::Hex8::Regular::nodesBottom ) - .def("nodesTop" , &GooseFEM::Mesh::Hex8::Regular::nodesTop ) - - .def("nodesFrontFace" , &GooseFEM::Mesh::Hex8::Regular::nodesFrontFace ) - .def("nodesBackFace" , &GooseFEM::Mesh::Hex8::Regular::nodesBackFace ) - .def("nodesLeftFace" , &GooseFEM::Mesh::Hex8::Regular::nodesLeftFace ) - .def("nodesRightFace" , &GooseFEM::Mesh::Hex8::Regular::nodesRightFace ) - .def("nodesBottomFace" , &GooseFEM::Mesh::Hex8::Regular::nodesBottomFace ) - .def("nodesTopFace" , &GooseFEM::Mesh::Hex8::Regular::nodesTopFace ) - - .def("nodesFrontBottomEdge" , &GooseFEM::Mesh::Hex8::Regular::nodesFrontBottomEdge ) - .def("nodesFrontTopEdge" , &GooseFEM::Mesh::Hex8::Regular::nodesFrontTopEdge ) - .def("nodesFrontLeftEdge" , &GooseFEM::Mesh::Hex8::Regular::nodesFrontLeftEdge ) - .def("nodesFrontRightEdge" , &GooseFEM::Mesh::Hex8::Regular::nodesFrontRightEdge ) - .def("nodesBackBottomEdge" , &GooseFEM::Mesh::Hex8::Regular::nodesBackBottomEdge ) - .def("nodesBackTopEdge" , &GooseFEM::Mesh::Hex8::Regular::nodesBackTopEdge ) - .def("nodesBackLeftEdge" , &GooseFEM::Mesh::Hex8::Regular::nodesBackLeftEdge ) - .def("nodesBackRightEdge" , &GooseFEM::Mesh::Hex8::Regular::nodesBackRightEdge ) - .def("nodesBottomLeftEdge" , &GooseFEM::Mesh::Hex8::Regular::nodesBottomLeftEdge ) - .def("nodesBottomRightEdge" , &GooseFEM::Mesh::Hex8::Regular::nodesBottomRightEdge ) - .def("nodesTopLeftEdge" , &GooseFEM::Mesh::Hex8::Regular::nodesTopLeftEdge ) - .def("nodesTopRightEdge" , &GooseFEM::Mesh::Hex8::Regular::nodesTopRightEdge ) - - .def("nodesBottomFrontEdge" , &GooseFEM::Mesh::Hex8::Regular::nodesBottomFrontEdge ) - .def("nodesBottomBackEdge" , &GooseFEM::Mesh::Hex8::Regular::nodesBottomBackEdge ) - .def("nodesTopFrontEdge" , &GooseFEM::Mesh::Hex8::Regular::nodesTopFrontEdge ) - .def("nodesTopBackEdge" , &GooseFEM::Mesh::Hex8::Regular::nodesTopBackEdge ) - .def("nodesLeftBottomEdge" , &GooseFEM::Mesh::Hex8::Regular::nodesLeftBottomEdge ) - .def("nodesLeftFrontEdge" , &GooseFEM::Mesh::Hex8::Regular::nodesLeftFrontEdge ) - .def("nodesLeftBackEdge" , &GooseFEM::Mesh::Hex8::Regular::nodesLeftBackEdge ) - .def("nodesLeftTopEdge" , &GooseFEM::Mesh::Hex8::Regular::nodesLeftTopEdge ) - .def("nodesRightBottomEdge" , &GooseFEM::Mesh::Hex8::Regular::nodesRightBottomEdge ) - .def("nodesRightTopEdge" , &GooseFEM::Mesh::Hex8::Regular::nodesRightTopEdge ) - .def("nodesRightFrontEdge" , &GooseFEM::Mesh::Hex8::Regular::nodesRightFrontEdge ) - .def("nodesRightBackEdge" , &GooseFEM::Mesh::Hex8::Regular::nodesRightBackEdge ) - - .def("nodesFrontBottomOpenEdge" , &GooseFEM::Mesh::Hex8::Regular::nodesFrontBottomOpenEdge ) - .def("nodesFrontTopOpenEdge" , &GooseFEM::Mesh::Hex8::Regular::nodesFrontTopOpenEdge ) - .def("nodesFrontLeftOpenEdge" , &GooseFEM::Mesh::Hex8::Regular::nodesFrontLeftOpenEdge ) - .def("nodesFrontRightOpenEdge" , &GooseFEM::Mesh::Hex8::Regular::nodesFrontRightOpenEdge ) - .def("nodesBackBottomOpenEdge" , &GooseFEM::Mesh::Hex8::Regular::nodesBackBottomOpenEdge ) - .def("nodesBackTopOpenEdge" , &GooseFEM::Mesh::Hex8::Regular::nodesBackTopOpenEdge ) - .def("nodesBackLeftOpenEdge" , &GooseFEM::Mesh::Hex8::Regular::nodesBackLeftOpenEdge ) - .def("nodesBackRightOpenEdge" , &GooseFEM::Mesh::Hex8::Regular::nodesBackRightOpenEdge ) - .def("nodesBottomLeftOpenEdge" , &GooseFEM::Mesh::Hex8::Regular::nodesBottomLeftOpenEdge ) - .def("nodesBottomRightOpenEdge" , &GooseFEM::Mesh::Hex8::Regular::nodesBottomRightOpenEdge ) - .def("nodesTopLeftOpenEdge" , &GooseFEM::Mesh::Hex8::Regular::nodesTopLeftOpenEdge ) - .def("nodesTopRightOpenEdge" , &GooseFEM::Mesh::Hex8::Regular::nodesTopRightOpenEdge ) - - .def("nodesBottomFrontOpenEdge" , &GooseFEM::Mesh::Hex8::Regular::nodesBottomFrontOpenEdge ) - .def("nodesBottomBackOpenEdge" , &GooseFEM::Mesh::Hex8::Regular::nodesBottomBackOpenEdge ) - .def("nodesTopFrontOpenEdge" , &GooseFEM::Mesh::Hex8::Regular::nodesTopFrontOpenEdge ) - .def("nodesTopBackOpenEdge" , &GooseFEM::Mesh::Hex8::Regular::nodesTopBackOpenEdge ) - .def("nodesLeftBottomOpenEdge" , &GooseFEM::Mesh::Hex8::Regular::nodesLeftBottomOpenEdge ) - .def("nodesLeftFrontOpenEdge" , &GooseFEM::Mesh::Hex8::Regular::nodesLeftFrontOpenEdge ) - .def("nodesLeftBackOpenEdge" , &GooseFEM::Mesh::Hex8::Regular::nodesLeftBackOpenEdge ) - .def("nodesLeftTopOpenEdge" , &GooseFEM::Mesh::Hex8::Regular::nodesLeftTopOpenEdge ) - .def("nodesRightBottomOpenEdge" , &GooseFEM::Mesh::Hex8::Regular::nodesRightBottomOpenEdge ) - .def("nodesRightTopOpenEdge" , &GooseFEM::Mesh::Hex8::Regular::nodesRightTopOpenEdge ) - .def("nodesRightFrontOpenEdge" , &GooseFEM::Mesh::Hex8::Regular::nodesRightFrontOpenEdge ) - .def("nodesRightBackOpenEdge" , &GooseFEM::Mesh::Hex8::Regular::nodesRightBackOpenEdge ) - - .def("nodesFrontBottomLeftCorner" , &GooseFEM::Mesh::Hex8::Regular::nodesFrontBottomLeftCorner ) - .def("nodesFrontBottomRightCorner", &GooseFEM::Mesh::Hex8::Regular::nodesFrontBottomRightCorner) - .def("nodesFrontTopLeftCorner" , &GooseFEM::Mesh::Hex8::Regular::nodesFrontTopLeftCorner ) - .def("nodesFrontTopRightCorner" , &GooseFEM::Mesh::Hex8::Regular::nodesFrontTopRightCorner ) - .def("nodesBackBottomLeftCorner" , &GooseFEM::Mesh::Hex8::Regular::nodesBackBottomLeftCorner ) - .def("nodesBackBottomRightCorner" , &GooseFEM::Mesh::Hex8::Regular::nodesBackBottomRightCorner ) - .def("nodesBackTopLeftCorner" , &GooseFEM::Mesh::Hex8::Regular::nodesBackTopLeftCorner ) - .def("nodesBackTopRightCorner" , &GooseFEM::Mesh::Hex8::Regular::nodesBackTopRightCorner ) - - .def("nodesFrontLeftBottomCorner" , &GooseFEM::Mesh::Hex8::Regular::nodesFrontLeftBottomCorner ) - .def("nodesBottomFrontLeftCorner" , &GooseFEM::Mesh::Hex8::Regular::nodesBottomFrontLeftCorner ) - .def("nodesBottomLeftFrontCorner" , &GooseFEM::Mesh::Hex8::Regular::nodesBottomLeftFrontCorner ) - .def("nodesLeftFrontBottomCorner" , &GooseFEM::Mesh::Hex8::Regular::nodesLeftFrontBottomCorner ) - .def("nodesLeftBottomFrontCorner" , &GooseFEM::Mesh::Hex8::Regular::nodesLeftBottomFrontCorner ) - .def("nodesFrontRightBottomCorner", &GooseFEM::Mesh::Hex8::Regular::nodesFrontRightBottomCorner) - .def("nodesBottomFrontRightCorner", &GooseFEM::Mesh::Hex8::Regular::nodesBottomFrontRightCorner) - .def("nodesBottomRightFrontCorner", &GooseFEM::Mesh::Hex8::Regular::nodesBottomRightFrontCorner) - .def("nodesRightFrontBottomCorner", &GooseFEM::Mesh::Hex8::Regular::nodesRightFrontBottomCorner) - .def("nodesRightBottomFrontCorner", &GooseFEM::Mesh::Hex8::Regular::nodesRightBottomFrontCorner) - .def("nodesFrontLeftTopCorner" , &GooseFEM::Mesh::Hex8::Regular::nodesFrontLeftTopCorner ) - .def("nodesTopFrontLeftCorner" , &GooseFEM::Mesh::Hex8::Regular::nodesTopFrontLeftCorner ) - .def("nodesTopLeftFrontCorner" , &GooseFEM::Mesh::Hex8::Regular::nodesTopLeftFrontCorner ) - .def("nodesLeftFrontTopCorner" , &GooseFEM::Mesh::Hex8::Regular::nodesLeftFrontTopCorner ) - .def("nodesLeftTopFrontCorner" , &GooseFEM::Mesh::Hex8::Regular::nodesLeftTopFrontCorner ) - .def("nodesFrontRightTopCorner" , &GooseFEM::Mesh::Hex8::Regular::nodesFrontRightTopCorner ) - .def("nodesTopFrontRightCorner" , &GooseFEM::Mesh::Hex8::Regular::nodesTopFrontRightCorner ) - .def("nodesTopRightFrontCorner" , &GooseFEM::Mesh::Hex8::Regular::nodesTopRightFrontCorner ) - .def("nodesRightFrontTopCorner" , &GooseFEM::Mesh::Hex8::Regular::nodesRightFrontTopCorner ) - .def("nodesRightTopFrontCorner" , &GooseFEM::Mesh::Hex8::Regular::nodesRightTopFrontCorner ) - .def("nodesBackLeftBottomCorner" , &GooseFEM::Mesh::Hex8::Regular::nodesBackLeftBottomCorner ) - .def("nodesBottomBackLeftCorner" , &GooseFEM::Mesh::Hex8::Regular::nodesBottomBackLeftCorner ) - .def("nodesBottomLeftBackCorner" , &GooseFEM::Mesh::Hex8::Regular::nodesBottomLeftBackCorner ) - .def("nodesLeftBackBottomCorner" , &GooseFEM::Mesh::Hex8::Regular::nodesLeftBackBottomCorner ) - .def("nodesLeftBottomBackCorner" , &GooseFEM::Mesh::Hex8::Regular::nodesLeftBottomBackCorner ) - .def("nodesBackRightBottomCorner" , &GooseFEM::Mesh::Hex8::Regular::nodesBackRightBottomCorner ) - .def("nodesBottomBackRightCorner" , &GooseFEM::Mesh::Hex8::Regular::nodesBottomBackRightCorner ) - .def("nodesBottomRightBackCorner" , &GooseFEM::Mesh::Hex8::Regular::nodesBottomRightBackCorner ) - .def("nodesRightBackBottomCorner" , &GooseFEM::Mesh::Hex8::Regular::nodesRightBackBottomCorner ) - .def("nodesRightBottomBackCorner" , &GooseFEM::Mesh::Hex8::Regular::nodesRightBottomBackCorner ) - .def("nodesBackLeftTopCorner" , &GooseFEM::Mesh::Hex8::Regular::nodesBackLeftTopCorner ) - .def("nodesTopBackLeftCorner" , &GooseFEM::Mesh::Hex8::Regular::nodesTopBackLeftCorner ) - .def("nodesTopLeftBackCorner" , &GooseFEM::Mesh::Hex8::Regular::nodesTopLeftBackCorner ) - .def("nodesLeftBackTopCorner" , &GooseFEM::Mesh::Hex8::Regular::nodesLeftBackTopCorner ) - .def("nodesLeftTopBackCorner" , &GooseFEM::Mesh::Hex8::Regular::nodesLeftTopBackCorner ) - .def("nodesBackRightTopCorner" , &GooseFEM::Mesh::Hex8::Regular::nodesBackRightTopCorner ) - .def("nodesTopBackRightCorner" , &GooseFEM::Mesh::Hex8::Regular::nodesTopBackRightCorner ) - .def("nodesTopRightBackCorner" , &GooseFEM::Mesh::Hex8::Regular::nodesTopRightBackCorner ) - .def("nodesRightBackTopCorner" , &GooseFEM::Mesh::Hex8::Regular::nodesRightBackTopCorner ) - .def("nodesRightTopBackCorner" , &GooseFEM::Mesh::Hex8::Regular::nodesRightTopBackCorner ) - - .def("nodesPeriodic" , &GooseFEM::Mesh::Hex8::Regular::nodesPeriodic ) - .def("nodesOrigin" , &GooseFEM::Mesh::Hex8::Regular::nodesOrigin ) - .def("dofs" , &GooseFEM::Mesh::Hex8::Regular::dofs ) - .def("dofsPeriodic" , &GooseFEM::Mesh::Hex8::Regular::dofsPeriodic ) - - .def("__repr__", [](const GooseFEM::Mesh::Hex8::Regular &){ return ""; }); - -// ------------------------------------------------------------------------------------------------- - -py::class_(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" , &GooseFEM::Mesh::Hex8::FineLayer::nelem ) - .def("nnode" , &GooseFEM::Mesh::Hex8::FineLayer::nnode ) - .def("nne" , &GooseFEM::Mesh::Hex8::FineLayer::nne ) - .def("ndim" , &GooseFEM::Mesh::Hex8::FineLayer::ndim ) - .def("shape" , &GooseFEM::Mesh::Hex8::FineLayer::shape ) - - .def("coor" , &GooseFEM::Mesh::Hex8::FineLayer::coor ) - .def("conn" , &GooseFEM::Mesh::Hex8::FineLayer::conn ) - - .def("elementsMiddleLayer" , &GooseFEM::Mesh::Hex8::FineLayer::elementsMiddleLayer ) - - .def("nodesFront" , &GooseFEM::Mesh::Hex8::FineLayer::nodesFront ) - .def("nodesBack" , &GooseFEM::Mesh::Hex8::FineLayer::nodesBack ) - .def("nodesLeft" , &GooseFEM::Mesh::Hex8::FineLayer::nodesLeft ) - .def("nodesRight" , &GooseFEM::Mesh::Hex8::FineLayer::nodesRight ) - .def("nodesBottom" , &GooseFEM::Mesh::Hex8::FineLayer::nodesBottom ) - .def("nodesTop" , &GooseFEM::Mesh::Hex8::FineLayer::nodesTop ) - - .def("nodesFrontFace" , &GooseFEM::Mesh::Hex8::FineLayer::nodesFrontFace ) - .def("nodesBackFace" , &GooseFEM::Mesh::Hex8::FineLayer::nodesBackFace ) - .def("nodesLeftFace" , &GooseFEM::Mesh::Hex8::FineLayer::nodesLeftFace ) - .def("nodesRightFace" , &GooseFEM::Mesh::Hex8::FineLayer::nodesRightFace ) - .def("nodesBottomFace" , &GooseFEM::Mesh::Hex8::FineLayer::nodesBottomFace ) - .def("nodesTopFace" , &GooseFEM::Mesh::Hex8::FineLayer::nodesTopFace ) - - .def("nodesFrontBottomEdge" , &GooseFEM::Mesh::Hex8::FineLayer::nodesFrontBottomEdge ) - .def("nodesFrontTopEdge" , &GooseFEM::Mesh::Hex8::FineLayer::nodesFrontTopEdge ) - .def("nodesFrontLeftEdge" , &GooseFEM::Mesh::Hex8::FineLayer::nodesFrontLeftEdge ) - .def("nodesFrontRightEdge" , &GooseFEM::Mesh::Hex8::FineLayer::nodesFrontRightEdge ) - .def("nodesBackBottomEdge" , &GooseFEM::Mesh::Hex8::FineLayer::nodesBackBottomEdge ) - .def("nodesBackTopEdge" , &GooseFEM::Mesh::Hex8::FineLayer::nodesBackTopEdge ) - .def("nodesBackLeftEdge" , &GooseFEM::Mesh::Hex8::FineLayer::nodesBackLeftEdge ) - .def("nodesBackRightEdge" , &GooseFEM::Mesh::Hex8::FineLayer::nodesBackRightEdge ) - .def("nodesBottomLeftEdge" , &GooseFEM::Mesh::Hex8::FineLayer::nodesBottomLeftEdge ) - .def("nodesBottomRightEdge" , &GooseFEM::Mesh::Hex8::FineLayer::nodesBottomRightEdge ) - .def("nodesTopLeftEdge" , &GooseFEM::Mesh::Hex8::FineLayer::nodesTopLeftEdge ) - .def("nodesTopRightEdge" , &GooseFEM::Mesh::Hex8::FineLayer::nodesTopRightEdge ) - - .def("nodesBottomFrontEdge" , &GooseFEM::Mesh::Hex8::FineLayer::nodesBottomFrontEdge ) - .def("nodesBottomBackEdge" , &GooseFEM::Mesh::Hex8::FineLayer::nodesBottomBackEdge ) - .def("nodesTopFrontEdge" , &GooseFEM::Mesh::Hex8::FineLayer::nodesTopFrontEdge ) - .def("nodesTopBackEdge" , &GooseFEM::Mesh::Hex8::FineLayer::nodesTopBackEdge ) - .def("nodesLeftBottomEdge" , &GooseFEM::Mesh::Hex8::FineLayer::nodesLeftBottomEdge ) - .def("nodesLeftFrontEdge" , &GooseFEM::Mesh::Hex8::FineLayer::nodesLeftFrontEdge ) - .def("nodesLeftBackEdge" , &GooseFEM::Mesh::Hex8::FineLayer::nodesLeftBackEdge ) - .def("nodesLeftTopEdge" , &GooseFEM::Mesh::Hex8::FineLayer::nodesLeftTopEdge ) - .def("nodesRightBottomEdge" , &GooseFEM::Mesh::Hex8::FineLayer::nodesRightBottomEdge ) - .def("nodesRightTopEdge" , &GooseFEM::Mesh::Hex8::FineLayer::nodesRightTopEdge ) - .def("nodesRightFrontEdge" , &GooseFEM::Mesh::Hex8::FineLayer::nodesRightFrontEdge ) - .def("nodesRightBackEdge" , &GooseFEM::Mesh::Hex8::FineLayer::nodesRightBackEdge ) - - .def("nodesFrontBottomOpenEdge" , &GooseFEM::Mesh::Hex8::FineLayer::nodesFrontBottomOpenEdge ) - .def("nodesFrontTopOpenEdge" , &GooseFEM::Mesh::Hex8::FineLayer::nodesFrontTopOpenEdge ) - .def("nodesFrontLeftOpenEdge" , &GooseFEM::Mesh::Hex8::FineLayer::nodesFrontLeftOpenEdge ) - .def("nodesFrontRightOpenEdge" , &GooseFEM::Mesh::Hex8::FineLayer::nodesFrontRightOpenEdge ) - .def("nodesBackBottomOpenEdge" , &GooseFEM::Mesh::Hex8::FineLayer::nodesBackBottomOpenEdge ) - .def("nodesBackTopOpenEdge" , &GooseFEM::Mesh::Hex8::FineLayer::nodesBackTopOpenEdge ) - .def("nodesBackLeftOpenEdge" , &GooseFEM::Mesh::Hex8::FineLayer::nodesBackLeftOpenEdge ) - .def("nodesBackRightOpenEdge" , &GooseFEM::Mesh::Hex8::FineLayer::nodesBackRightOpenEdge ) - .def("nodesBottomLeftOpenEdge" , &GooseFEM::Mesh::Hex8::FineLayer::nodesBottomLeftOpenEdge ) - .def("nodesBottomRightOpenEdge" , &GooseFEM::Mesh::Hex8::FineLayer::nodesBottomRightOpenEdge ) - .def("nodesTopLeftOpenEdge" , &GooseFEM::Mesh::Hex8::FineLayer::nodesTopLeftOpenEdge ) - .def("nodesTopRightOpenEdge" , &GooseFEM::Mesh::Hex8::FineLayer::nodesTopRightOpenEdge ) - - .def("nodesBottomFrontOpenEdge" , &GooseFEM::Mesh::Hex8::FineLayer::nodesBottomFrontOpenEdge ) - .def("nodesBottomBackOpenEdge" , &GooseFEM::Mesh::Hex8::FineLayer::nodesBottomBackOpenEdge ) - .def("nodesTopFrontOpenEdge" , &GooseFEM::Mesh::Hex8::FineLayer::nodesTopFrontOpenEdge ) - .def("nodesTopBackOpenEdge" , &GooseFEM::Mesh::Hex8::FineLayer::nodesTopBackOpenEdge ) - .def("nodesLeftBottomOpenEdge" , &GooseFEM::Mesh::Hex8::FineLayer::nodesLeftBottomOpenEdge ) - .def("nodesLeftFrontOpenEdge" , &GooseFEM::Mesh::Hex8::FineLayer::nodesLeftFrontOpenEdge ) - .def("nodesLeftBackOpenEdge" , &GooseFEM::Mesh::Hex8::FineLayer::nodesLeftBackOpenEdge ) - .def("nodesLeftTopOpenEdge" , &GooseFEM::Mesh::Hex8::FineLayer::nodesLeftTopOpenEdge ) - .def("nodesRightBottomOpenEdge" , &GooseFEM::Mesh::Hex8::FineLayer::nodesRightBottomOpenEdge ) - .def("nodesRightTopOpenEdge" , &GooseFEM::Mesh::Hex8::FineLayer::nodesRightTopOpenEdge ) - .def("nodesRightFrontOpenEdge" , &GooseFEM::Mesh::Hex8::FineLayer::nodesRightFrontOpenEdge ) - .def("nodesRightBackOpenEdge" , &GooseFEM::Mesh::Hex8::FineLayer::nodesRightBackOpenEdge ) - - .def("nodesFrontBottomLeftCorner" , &GooseFEM::Mesh::Hex8::FineLayer::nodesFrontBottomLeftCorner ) - .def("nodesFrontBottomRightCorner", &GooseFEM::Mesh::Hex8::FineLayer::nodesFrontBottomRightCorner) - .def("nodesFrontTopLeftCorner" , &GooseFEM::Mesh::Hex8::FineLayer::nodesFrontTopLeftCorner ) - .def("nodesFrontTopRightCorner" , &GooseFEM::Mesh::Hex8::FineLayer::nodesFrontTopRightCorner ) - .def("nodesBackBottomLeftCorner" , &GooseFEM::Mesh::Hex8::FineLayer::nodesBackBottomLeftCorner ) - .def("nodesBackBottomRightCorner" , &GooseFEM::Mesh::Hex8::FineLayer::nodesBackBottomRightCorner ) - .def("nodesBackTopLeftCorner" , &GooseFEM::Mesh::Hex8::FineLayer::nodesBackTopLeftCorner ) - .def("nodesBackTopRightCorner" , &GooseFEM::Mesh::Hex8::FineLayer::nodesBackTopRightCorner ) - - .def("nodesFrontLeftBottomCorner" , &GooseFEM::Mesh::Hex8::FineLayer::nodesFrontLeftBottomCorner ) - .def("nodesBottomFrontLeftCorner" , &GooseFEM::Mesh::Hex8::FineLayer::nodesBottomFrontLeftCorner ) - .def("nodesBottomLeftFrontCorner" , &GooseFEM::Mesh::Hex8::FineLayer::nodesBottomLeftFrontCorner ) - .def("nodesLeftFrontBottomCorner" , &GooseFEM::Mesh::Hex8::FineLayer::nodesLeftFrontBottomCorner ) - .def("nodesLeftBottomFrontCorner" , &GooseFEM::Mesh::Hex8::FineLayer::nodesLeftBottomFrontCorner ) - .def("nodesFrontRightBottomCorner", &GooseFEM::Mesh::Hex8::FineLayer::nodesFrontRightBottomCorner) - .def("nodesBottomFrontRightCorner", &GooseFEM::Mesh::Hex8::FineLayer::nodesBottomFrontRightCorner) - .def("nodesBottomRightFrontCorner", &GooseFEM::Mesh::Hex8::FineLayer::nodesBottomRightFrontCorner) - .def("nodesRightFrontBottomCorner", &GooseFEM::Mesh::Hex8::FineLayer::nodesRightFrontBottomCorner) - .def("nodesRightBottomFrontCorner", &GooseFEM::Mesh::Hex8::FineLayer::nodesRightBottomFrontCorner) - .def("nodesFrontLeftTopCorner" , &GooseFEM::Mesh::Hex8::FineLayer::nodesFrontLeftTopCorner ) - .def("nodesTopFrontLeftCorner" , &GooseFEM::Mesh::Hex8::FineLayer::nodesTopFrontLeftCorner ) - .def("nodesTopLeftFrontCorner" , &GooseFEM::Mesh::Hex8::FineLayer::nodesTopLeftFrontCorner ) - .def("nodesLeftFrontTopCorner" , &GooseFEM::Mesh::Hex8::FineLayer::nodesLeftFrontTopCorner ) - .def("nodesLeftTopFrontCorner" , &GooseFEM::Mesh::Hex8::FineLayer::nodesLeftTopFrontCorner ) - .def("nodesFrontRightTopCorner" , &GooseFEM::Mesh::Hex8::FineLayer::nodesFrontRightTopCorner ) - .def("nodesTopFrontRightCorner" , &GooseFEM::Mesh::Hex8::FineLayer::nodesTopFrontRightCorner ) - .def("nodesTopRightFrontCorner" , &GooseFEM::Mesh::Hex8::FineLayer::nodesTopRightFrontCorner ) - .def("nodesRightFrontTopCorner" , &GooseFEM::Mesh::Hex8::FineLayer::nodesRightFrontTopCorner ) - .def("nodesRightTopFrontCorner" , &GooseFEM::Mesh::Hex8::FineLayer::nodesRightTopFrontCorner ) - .def("nodesBackLeftBottomCorner" , &GooseFEM::Mesh::Hex8::FineLayer::nodesBackLeftBottomCorner ) - .def("nodesBottomBackLeftCorner" , &GooseFEM::Mesh::Hex8::FineLayer::nodesBottomBackLeftCorner ) - .def("nodesBottomLeftBackCorner" , &GooseFEM::Mesh::Hex8::FineLayer::nodesBottomLeftBackCorner ) - .def("nodesLeftBackBottomCorner" , &GooseFEM::Mesh::Hex8::FineLayer::nodesLeftBackBottomCorner ) - .def("nodesLeftBottomBackCorner" , &GooseFEM::Mesh::Hex8::FineLayer::nodesLeftBottomBackCorner ) - .def("nodesBackRightBottomCorner" , &GooseFEM::Mesh::Hex8::FineLayer::nodesBackRightBottomCorner ) - .def("nodesBottomBackRightCorner" , &GooseFEM::Mesh::Hex8::FineLayer::nodesBottomBackRightCorner ) - .def("nodesBottomRightBackCorner" , &GooseFEM::Mesh::Hex8::FineLayer::nodesBottomRightBackCorner ) - .def("nodesRightBackBottomCorner" , &GooseFEM::Mesh::Hex8::FineLayer::nodesRightBackBottomCorner ) - .def("nodesRightBottomBackCorner" , &GooseFEM::Mesh::Hex8::FineLayer::nodesRightBottomBackCorner ) - .def("nodesBackLeftTopCorner" , &GooseFEM::Mesh::Hex8::FineLayer::nodesBackLeftTopCorner ) - .def("nodesTopBackLeftCorner" , &GooseFEM::Mesh::Hex8::FineLayer::nodesTopBackLeftCorner ) - .def("nodesTopLeftBackCorner" , &GooseFEM::Mesh::Hex8::FineLayer::nodesTopLeftBackCorner ) - .def("nodesLeftBackTopCorner" , &GooseFEM::Mesh::Hex8::FineLayer::nodesLeftBackTopCorner ) - .def("nodesLeftTopBackCorner" , &GooseFEM::Mesh::Hex8::FineLayer::nodesLeftTopBackCorner ) - .def("nodesBackRightTopCorner" , &GooseFEM::Mesh::Hex8::FineLayer::nodesBackRightTopCorner ) - .def("nodesTopBackRightCorner" , &GooseFEM::Mesh::Hex8::FineLayer::nodesTopBackRightCorner ) - .def("nodesTopRightBackCorner" , &GooseFEM::Mesh::Hex8::FineLayer::nodesTopRightBackCorner ) - .def("nodesRightBackTopCorner" , &GooseFEM::Mesh::Hex8::FineLayer::nodesRightBackTopCorner ) - .def("nodesRightTopBackCorner" , &GooseFEM::Mesh::Hex8::FineLayer::nodesRightTopBackCorner ) - - .def("nodesPeriodic" , &GooseFEM::Mesh::Hex8::FineLayer::nodesPeriodic ) - .def("nodesOrigin" , &GooseFEM::Mesh::Hex8::FineLayer::nodesOrigin ) - - .def("dofs" , &GooseFEM::Mesh::Hex8::FineLayer::dofs ) - .def("dofsPeriodic" , &GooseFEM::Mesh::Hex8::FineLayer::dofsPeriodic ) - - .def("__repr__", [](const GooseFEM::Mesh::Hex8::FineLayer &){ return ""; }); - -// ------------------------------------------------------------------------------------------------- - -} - -// ================================================================================================= - -{ - -py::module sm = mMesh.def_submodule("Quad4", "Linear quadrilateral elements (2D)"); - -// ------------------------------------------------------------------------------------------------- - -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" , &GooseFEM::Mesh::Quad4::Regular::coor ) - .def("conn" , &GooseFEM::Mesh::Quad4::Regular::conn ) - .def("nelem" , &GooseFEM::Mesh::Quad4::Regular::nelem ) - .def("nnode" , &GooseFEM::Mesh::Quad4::Regular::nnode ) - .def("nne" , &GooseFEM::Mesh::Quad4::Regular::nne ) - .def("ndim" , &GooseFEM::Mesh::Quad4::Regular::ndim ) - - .def("nodesBottomEdge" , &GooseFEM::Mesh::Quad4::Regular::nodesBottomEdge ) - .def("nodesTopEdge" , &GooseFEM::Mesh::Quad4::Regular::nodesTopEdge ) - .def("nodesLeftEdge" , &GooseFEM::Mesh::Quad4::Regular::nodesLeftEdge ) - .def("nodesRightEdge" , &GooseFEM::Mesh::Quad4::Regular::nodesRightEdge ) - .def("nodesBottomOpenEdge" , &GooseFEM::Mesh::Quad4::Regular::nodesBottomOpenEdge ) - .def("nodesTopOpenEdge" , &GooseFEM::Mesh::Quad4::Regular::nodesTopOpenEdge ) - .def("nodesLeftOpenEdge" , &GooseFEM::Mesh::Quad4::Regular::nodesLeftOpenEdge ) - .def("nodesRightOpenEdge" , &GooseFEM::Mesh::Quad4::Regular::nodesRightOpenEdge ) - - .def("nodesBottomLeftCorner" , &GooseFEM::Mesh::Quad4::Regular::nodesBottomLeftCorner ) - .def("nodesBottomRightCorner", &GooseFEM::Mesh::Quad4::Regular::nodesBottomRightCorner) - .def("nodesTopLeftCorner" , &GooseFEM::Mesh::Quad4::Regular::nodesTopLeftCorner ) - .def("nodesTopRightCorner" , &GooseFEM::Mesh::Quad4::Regular::nodesTopRightCorner ) - .def("nodesLeftBottomCorner" , &GooseFEM::Mesh::Quad4::Regular::nodesLeftBottomCorner ) - .def("nodesLeftTopCorner" , &GooseFEM::Mesh::Quad4::Regular::nodesLeftTopCorner ) - .def("nodesRightBottomCorner", &GooseFEM::Mesh::Quad4::Regular::nodesRightBottomCorner) - .def("nodesRightTopCorner" , &GooseFEM::Mesh::Quad4::Regular::nodesRightTopCorner ) - - .def("nodesPeriodic" , &GooseFEM::Mesh::Quad4::Regular::nodesPeriodic ) - .def("nodesOrigin" , &GooseFEM::Mesh::Quad4::Regular::nodesOrigin ) - - .def("dofs" , &GooseFEM::Mesh::Quad4::Regular::dofs ) - .def("dofsPeriodic" , &GooseFEM::Mesh::Quad4::Regular::dofsPeriodic ) - - .def("__repr__", [](const GooseFEM::Mesh::Quad4::Regular &){ return ""; }); - -// ------------------------------------------------------------------------------------------------- - -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" , &GooseFEM::Mesh::Quad4::FineLayer::shape ) - .def("coor" , &GooseFEM::Mesh::Quad4::FineLayer::coor ) - .def("conn" , &GooseFEM::Mesh::Quad4::FineLayer::conn ) - .def("nelem" , &GooseFEM::Mesh::Quad4::FineLayer::nelem ) - .def("nnode" , &GooseFEM::Mesh::Quad4::FineLayer::nnode ) - .def("nne" , &GooseFEM::Mesh::Quad4::FineLayer::nne ) - .def("ndim" , &GooseFEM::Mesh::Quad4::FineLayer::ndim ) - .def("elementsMiddleLayer" , &GooseFEM::Mesh::Quad4::FineLayer::elementsMiddleLayer ) - .def("nodesBottomEdge" , &GooseFEM::Mesh::Quad4::FineLayer::nodesBottomEdge ) - .def("nodesTopEdge" , &GooseFEM::Mesh::Quad4::FineLayer::nodesTopEdge ) - .def("nodesLeftEdge" , &GooseFEM::Mesh::Quad4::FineLayer::nodesLeftEdge ) - .def("nodesRightEdge" , &GooseFEM::Mesh::Quad4::FineLayer::nodesRightEdge ) - .def("nodesBottomOpenEdge" , &GooseFEM::Mesh::Quad4::FineLayer::nodesBottomOpenEdge ) - .def("nodesTopOpenEdge" , &GooseFEM::Mesh::Quad4::FineLayer::nodesTopOpenEdge ) - .def("nodesLeftOpenEdge" , &GooseFEM::Mesh::Quad4::FineLayer::nodesLeftOpenEdge ) - .def("nodesRightOpenEdge" , &GooseFEM::Mesh::Quad4::FineLayer::nodesRightOpenEdge ) - .def("nodesBottomLeftCorner" , &GooseFEM::Mesh::Quad4::FineLayer::nodesBottomLeftCorner ) - .def("nodesBottomRightCorner", &GooseFEM::Mesh::Quad4::FineLayer::nodesBottomRightCorner) - .def("nodesTopLeftCorner" , &GooseFEM::Mesh::Quad4::FineLayer::nodesTopLeftCorner ) - .def("nodesTopRightCorner" , &GooseFEM::Mesh::Quad4::FineLayer::nodesTopRightCorner ) - .def("nodesLeftBottomCorner" , &GooseFEM::Mesh::Quad4::FineLayer::nodesLeftBottomCorner ) - .def("nodesLeftTopCorner" , &GooseFEM::Mesh::Quad4::FineLayer::nodesLeftTopCorner ) - .def("nodesRightBottomCorner", &GooseFEM::Mesh::Quad4::FineLayer::nodesRightBottomCorner) - .def("nodesRightTopCorner" , &GooseFEM::Mesh::Quad4::FineLayer::nodesRightTopCorner ) - .def("nodesPeriodic" , &GooseFEM::Mesh::Quad4::FineLayer::nodesPeriodic ) - .def("nodesOrigin" , &GooseFEM::Mesh::Quad4::FineLayer::nodesOrigin ) - .def("dofs" , &GooseFEM::Mesh::Quad4::FineLayer::dofs ) - .def("dofsPeriodic" , &GooseFEM::Mesh::Quad4::FineLayer::dofsPeriodic ) - - .def("__repr__", - [](const GooseFEM::Mesh::Quad4::FineLayer &){ return ""; } - ); - -// ------------------------------------------------------------------------------------------------- - -} - -// ================================================================================================= - -{ - -py::module sm = mMesh.def_submodule("Tri3" , "Linear triangular elements (2D)"); - -// ------------------------------------------------------------------------------------------------- - -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" , &GooseFEM::Mesh::Tri3::Regular::coor ) - .def("conn" , &GooseFEM::Mesh::Tri3::Regular::conn ) - .def("nelem" , &GooseFEM::Mesh::Tri3::Regular::nelem ) - .def("nnode" , &GooseFEM::Mesh::Tri3::Regular::nnode ) - .def("nne" , &GooseFEM::Mesh::Tri3::Regular::nne ) - .def("ndim" , &GooseFEM::Mesh::Tri3::Regular::ndim ) - - .def("nodesBottomEdge" , &GooseFEM::Mesh::Tri3::Regular::nodesBottomEdge ) - .def("nodesTopEdge" , &GooseFEM::Mesh::Tri3::Regular::nodesTopEdge ) - .def("nodesLeftEdge" , &GooseFEM::Mesh::Tri3::Regular::nodesLeftEdge ) - .def("nodesRightEdge" , &GooseFEM::Mesh::Tri3::Regular::nodesRightEdge ) - .def("nodesBottomOpenEdge" , &GooseFEM::Mesh::Tri3::Regular::nodesBottomOpenEdge ) - .def("nodesTopOpenEdge" , &GooseFEM::Mesh::Tri3::Regular::nodesTopOpenEdge ) - .def("nodesLeftOpenEdge" , &GooseFEM::Mesh::Tri3::Regular::nodesLeftOpenEdge ) - .def("nodesRightOpenEdge" , &GooseFEM::Mesh::Tri3::Regular::nodesRightOpenEdge ) - - .def("nodesBottomLeftCorner" , &GooseFEM::Mesh::Tri3::Regular::nodesBottomLeftCorner ) - .def("nodesBottomRightCorner", &GooseFEM::Mesh::Tri3::Regular::nodesBottomRightCorner) - .def("nodesTopLeftCorner" , &GooseFEM::Mesh::Tri3::Regular::nodesTopLeftCorner ) - .def("nodesTopRightCorner" , &GooseFEM::Mesh::Tri3::Regular::nodesTopRightCorner ) - .def("nodesLeftBottomCorner" , &GooseFEM::Mesh::Tri3::Regular::nodesLeftBottomCorner ) - .def("nodesLeftTopCorner" , &GooseFEM::Mesh::Tri3::Regular::nodesLeftTopCorner ) - .def("nodesRightBottomCorner", &GooseFEM::Mesh::Tri3::Regular::nodesRightBottomCorner) - .def("nodesRightTopCorner" , &GooseFEM::Mesh::Tri3::Regular::nodesRightTopCorner ) - - .def("nodesPeriodic" , &GooseFEM::Mesh::Tri3::Regular::nodesPeriodic ) - .def("nodesOrigin" , &GooseFEM::Mesh::Tri3::Regular::nodesOrigin ) - - .def("dofs" , &GooseFEM::Mesh::Tri3::Regular::dofs ) - .def("dofsPeriodic" , &GooseFEM::Mesh::Tri3::Regular::dofsPeriodic ) - - .def("__repr__", [](const GooseFEM::Mesh::Tri3::Regular &){ return ""; }); - -// ------------------------------------------------------------------------------------------------- - -sm.def("getOrientation", &GooseFEM::Mesh::Tri3::getOrientation, "Get the orientation of each element", py::arg("coor"), py::arg("conn")); - -sm.def("retriangulate", &GooseFEM::Mesh::Tri3::retriangulate, "Re-triangulate existing mesh", py::arg("coor"), py::arg("conn"), py::arg("orientation")=-1); - -// ------------------------------------------------------------------------------------------------- - -} - -// ================================================================================================= - -} - diff --git a/python/Element.hpp b/python/Element.hpp new file mode 100644 index 0000000..76cdb5a --- /dev/null +++ b/python/Element.hpp @@ -0,0 +1,31 @@ +/* ================================================================================================= + +(c - GPLv3) T.W.J. de Geus (Tom) | tom@geus.me | www.geus.me | github.com/tdegeus/GooseFEM + +================================================================================================= */ + +#include + +#include +#include + +#include + +#include "../include/GooseFEM/GooseFEM.h" + +// ================================================================================================= + +namespace py = pybind11; + +// ================================================================================================= + +void init_Element(py::module &m) +{ + +m.def("asElementVector" , &GooseFEM::Element::asElementVector , "Covert to 'elemvec'", py::arg("conn"), py::arg("nodevec")); +m.def("assembleElementVector", &GooseFEM::Element::assembleNodeVector, "Assemble 'nodevec'" , py::arg("conn"), py::arg("elemvec")); + +} + +// ================================================================================================= + diff --git a/python/ElementHex8.hpp b/python/ElementHex8.hpp new file mode 100644 index 0000000..175ae37 --- /dev/null +++ b/python/ElementHex8.hpp @@ -0,0 +1,73 @@ +/* ================================================================================================= + +(c - GPLv3) T.W.J. de Geus (Tom) | tom@geus.me | www.geus.me | github.com/tdegeus/GooseFEM + +================================================================================================= */ + +#include + +#include +#include + +#include + +#include "../include/GooseFEM/GooseFEM.h" + +// ================================================================================================= + +namespace py = pybind11; + +// ================================================================================================= + +void init_ElementHex8(py::module &m) +{ + +py::class_(m, "Quadrature") + + .def(py::init &>(), "Quadrature", py::arg("x")) + + .def(py::init &, const xt::xtensor &, const xt::xtensor &>(), "Quadrature", py::arg("x"), py::arg("xi"), py::arg("w")) + + .def("nelem", &GooseFEM::Element::Hex8::Quadrature::nelem, "Return number of elements" ) + .def("nne" , &GooseFEM::Element::Hex8::Quadrature::nne , "Return number of nodes per element" ) + .def("ndim" , &GooseFEM::Element::Hex8::Quadrature::ndim , "Return number of dimensions" ) + .def("nip" , &GooseFEM::Element::Hex8::Quadrature::nip , "Return number of integration points") + + .def("dV" , py::overload_cast<>(&GooseFEM::Element::Hex8::Quadrature::dV , py::const_), "Integration point volume (qscalar)") + .def("dVtensor", py::overload_cast<>(&GooseFEM::Element::Hex8::Quadrature::dVtensor, py::const_), "Integration point volume (qtensor)") + + .def("gradN_vector" , py::overload_cast &>(&GooseFEM::Element::Hex8::Quadrature::gradN_vector , py::const_), "Dyadic product, returns 'qtensor'", py::arg("elemvec")) + .def("gradN_vector_T" , py::overload_cast &>(&GooseFEM::Element::Hex8::Quadrature::gradN_vector_T , py::const_), "Dyadic product, returns 'qtensor'", py::arg("elemvec")) + .def("symGradN_vector", py::overload_cast &>(&GooseFEM::Element::Hex8::Quadrature::symGradN_vector, py::const_), "Dyadic product, returns 'qtensor'", py::arg("elemvec")) + + .def("int_N_scalar_NT_dV" , py::overload_cast &>(&GooseFEM::Element::Hex8::Quadrature::int_N_scalar_NT_dV , py::const_), "Integration, returns 'elemmat'", py::arg("qscalar")) + .def("int_gradN_dot_tensor2_dV", py::overload_cast &>(&GooseFEM::Element::Hex8::Quadrature::int_gradN_dot_tensor2_dV, py::const_), "Integration, returns 'elemvec'", py::arg("qtensor")) + + .def("__repr__", [](const GooseFEM::Element::Hex8::Quadrature &){ return ""; }); + +} + +// ------------------------------------------------------------------------------------------------- + +void init_ElementHex8Gauss(py::module &m) +{ + +m.def("nip", &GooseFEM::Element::Hex8::Gauss::nip, "Return number of integration point" ); +m.def("xi" , &GooseFEM::Element::Hex8::Gauss::xi , "Return integration point coordinates"); +m.def("w" , &GooseFEM::Element::Hex8::Gauss::w , "Return integration point weights" ); + +} + +// ------------------------------------------------------------------------------------------------- + +void init_ElementHex8Nodal(py::module &m) +{ + +m.def("nip", &GooseFEM::Element::Hex8::Nodal::nip, "Return number of integration point" ); +m.def("xi" , &GooseFEM::Element::Hex8::Nodal::xi , "Return integration point coordinates"); +m.def("w" , &GooseFEM::Element::Hex8::Nodal::w , "Return integration point weights" ); + +} + +// ================================================================================================= + diff --git a/python/ElementQuad4.hpp b/python/ElementQuad4.hpp new file mode 100644 index 0000000..8bc0943 --- /dev/null +++ b/python/ElementQuad4.hpp @@ -0,0 +1,73 @@ +/* ================================================================================================= + +(c - GPLv3) T.W.J. de Geus (Tom) | tom@geus.me | www.geus.me | github.com/tdegeus/GooseFEM + +================================================================================================= */ + +#include + +#include +#include + +#include + +#include "../include/GooseFEM/GooseFEM.h" + +// ================================================================================================= + +namespace py = pybind11; + +// ================================================================================================= + +void init_ElementQuad4(py::module &m) +{ + +py::class_(m, "Quadrature") + + .def(py::init &>(), "Quadrature", py::arg("x")) + + .def(py::init &, const xt::xtensor &, const xt::xtensor &>(), "Quadrature", py::arg("x"), py::arg("xi"), py::arg("w")) + + .def("nelem", &GooseFEM::Element::Quad4::Quadrature::nelem, "Return number of elements" ) + .def("nne" , &GooseFEM::Element::Quad4::Quadrature::nne , "Return number of nodes per element" ) + .def("ndim" , &GooseFEM::Element::Quad4::Quadrature::ndim , "Return number of dimensions" ) + .def("nip" , &GooseFEM::Element::Quad4::Quadrature::nip , "Return number of integration points") + + .def("dV" , py::overload_cast<>(&GooseFEM::Element::Quad4::Quadrature::dV , py::const_), "Integration point volume (qscalar)") + .def("dVtensor", py::overload_cast<>(&GooseFEM::Element::Quad4::Quadrature::dVtensor, py::const_), "Integration point volume (qtensor)") + + .def("gradN_vector" , py::overload_cast &>(&GooseFEM::Element::Quad4::Quadrature::gradN_vector , py::const_), "Dyadic product, returns 'qtensor'", py::arg("elemvec")) + .def("gradN_vector_T" , py::overload_cast &>(&GooseFEM::Element::Quad4::Quadrature::gradN_vector_T , py::const_), "Dyadic product, returns 'qtensor'", py::arg("elemvec")) + .def("symGradN_vector", py::overload_cast &>(&GooseFEM::Element::Quad4::Quadrature::symGradN_vector, py::const_), "Dyadic product, returns 'qtensor'", py::arg("elemvec")) + + .def("int_N_scalar_NT_dV" , py::overload_cast &>(&GooseFEM::Element::Quad4::Quadrature::int_N_scalar_NT_dV , py::const_), "Integration, returns 'elemmat'", py::arg("qscalar")) + .def("int_gradN_dot_tensor2_dV", py::overload_cast &>(&GooseFEM::Element::Quad4::Quadrature::int_gradN_dot_tensor2_dV, py::const_), "Integration, returns 'elemvec'", py::arg("qtensor")) + + .def("__repr__", [](const GooseFEM::Element::Quad4::Quadrature &){ return ""; }); + +} + +// ------------------------------------------------------------------------------------------------- + +void init_ElementQuad4Gauss(py::module &m) +{ + +m.def("nip", &GooseFEM::Element::Quad4::Gauss::nip, "Return number of integration point" ); +m.def("xi" , &GooseFEM::Element::Quad4::Gauss::xi , "Return integration point coordinates"); +m.def("w" , &GooseFEM::Element::Quad4::Gauss::w , "Return integration point weights" ); + +} + +// ------------------------------------------------------------------------------------------------- + +void init_ElementQuad4Nodal(py::module &m) +{ + +m.def("nip", &GooseFEM::Element::Quad4::Nodal::nip, "Return number of integration point" ); +m.def("xi" , &GooseFEM::Element::Quad4::Nodal::xi , "Return integration point coordinates"); +m.def("w" , &GooseFEM::Element::Quad4::Nodal::w , "Return integration point weights" ); + +} + +// ================================================================================================= + diff --git a/python/MatrixDiagonalPartitioned.hpp b/python/MatrixDiagonalPartitioned.hpp new file mode 100644 index 0000000..2ce687d --- /dev/null +++ b/python/MatrixDiagonalPartitioned.hpp @@ -0,0 +1,54 @@ +/* ================================================================================================= + +(c - GPLv3) T.W.J. de Geus (Tom) | tom@geus.me | www.geus.me | github.com/tdegeus/GooseFEM + +================================================================================================= */ + +#include + +#include +#include + +#include + +#include "../include/GooseFEM/GooseFEM.h" + +// ================================================================================================= + +namespace py = pybind11; + +// ================================================================================================= + +void init_MatrixDiagonalPartitioned(py::module &m) +{ + +py::class_(m, "MatrixDiagonalPartitioned") + + .def(py::init &, const xt::xtensor &, const xt::xtensor &>(), "Diagonal matrix", py::arg("conn"), py::arg("dofs"), py::arg("iip")) + + .def("nelem", &GooseFEM::MatrixDiagonalPartitioned::nelem, "Return number of element") + .def("nne" , &GooseFEM::MatrixDiagonalPartitioned::nne , "Return number of nodes per element") + .def("nnode", &GooseFEM::MatrixDiagonalPartitioned::nnode, "Return number of nodes") + .def("ndim" , &GooseFEM::MatrixDiagonalPartitioned::ndim , "Return number of dimensions") + .def("ndof" , &GooseFEM::MatrixDiagonalPartitioned::ndof , "Return number of degrees-of-freedom") + .def("nnu" , &GooseFEM::MatrixDiagonalPartitioned::nnu , "Return number of unknown degrees-of-freedom") + .def("nnp" , &GooseFEM::MatrixDiagonalPartitioned::nnp , "Return number of prescribed degrees-of-freedom") + + .def("assemble", &GooseFEM::MatrixDiagonalPartitioned::assemble, "Assemble matrix from 'elemmat", py::arg("elemmat")) + + .def("dofs" , &GooseFEM::MatrixDiagonalPartitioned::dofs , "Return degrees-of-freedom") + .def("iiu" , &GooseFEM::MatrixDiagonalPartitioned::iiu , "Return unknown degrees-of-freedom") + .def("iip" , &GooseFEM::MatrixDiagonalPartitioned::iip , "Return prescribed degrees-of-freedom") + + .def("dot" , py::overload_cast& >(&GooseFEM::MatrixDiagonalPartitioned::dot , py::const_), "Dot product 'b_i = A_ij * x_j" , py::arg("x")) + .def("dot_u", py::overload_cast&, const xt::xtensor&>(&GooseFEM::MatrixDiagonalPartitioned::dot_u, py::const_), "Dot product 'b_i = A_ij * x_j (b_u = A_uu * x_u + A_up * x_p == A_uu * x_u)", py::arg("x_u"), py::arg("x_p")) + .def("dot_p", py::overload_cast&, const xt::xtensor&>(&GooseFEM::MatrixDiagonalPartitioned::dot_p, py::const_), "Dot product 'b_i = A_ij * x_j (b_p = A_pu * x_u + A_pp * x_p == A_pp * x_p)", py::arg("x_u"), py::arg("x_p")) + + .def("asDiagonal", &GooseFEM::MatrixDiagonalPartitioned::asDiagonal, "Return as diagonal matrix (column)") + + .def("__repr__", [](const GooseFEM::MatrixDiagonalPartitioned &){ return ""; }); + +} + +// ================================================================================================= + diff --git a/python/Mesh.hpp b/python/Mesh.hpp new file mode 100644 index 0000000..1baecc7 --- /dev/null +++ b/python/Mesh.hpp @@ -0,0 +1,59 @@ +/* ================================================================================================= + +(c - GPLv3) T.W.J. de Geus (Tom) | tom@geus.me | www.geus.me | github.com/tdegeus/GooseFEM + +================================================================================================= */ + +#include + +#include +#include + +#include + +#include "../include/GooseFEM/GooseFEM.h" + +// ================================================================================================= + +namespace py = pybind11; + +// ================================================================================================= + +void init_Mesh(py::module &m) +{ + +py::class_(m, "Renumber") + + .def(py::init&>(), "Renumber", py::arg("dofs")) + + .def("get", &GooseFEM::Mesh::Renumber::get, "Renumber list") + .def("index", &GooseFEM::Mesh::Renumber::index, "Get index list to apply renumbering") + + .def("__repr__", [](const GooseFEM::Mesh::Renumber &){ return ""; }); + +// ------------------------------------------------------------------------------------------------- + +py::class_(m, "Reorder") + + .def(py::init([](xt::xtensor& a) { return new GooseFEM::Mesh::Reorder({a}); })) + .def(py::init([](xt::xtensor& a, xt::xtensor& b) { return new GooseFEM::Mesh::Reorder({a,b}); })) + .def(py::init([](xt::xtensor& a, xt::xtensor& b, xt::xtensor& c) { return new GooseFEM::Mesh::Reorder({a,b,c}); })) + .def(py::init([](xt::xtensor& a, xt::xtensor& b, xt::xtensor& c, xt::xtensor& d) { return new GooseFEM::Mesh::Reorder({a,b,c,d}); })) + + .def("get", &GooseFEM::Mesh::Reorder::get, "Reorder list") + .def("index", &GooseFEM::Mesh::Reorder::index, "Get index list to apply renumbering") + + .def("__repr__", [](const GooseFEM::Mesh::Reorder &){ return ""; }); + +// ------------------------------------------------------------------------------------------------- + +m.def("dofs", &GooseFEM::Mesh::dofs, "List with DOF-numbers (in sequential order)", py::arg("nnode"), py::arg("ndim")); + +m.def("coordination", &GooseFEM::Mesh::coordination, "Coordination number of each node", py::arg("conn")); + +m.def("elem2node", &GooseFEM::Mesh::elem2node, "Elements connect to each node", py::arg("conn")); + +} + +// ================================================================================================= + diff --git a/python/MeshHex8.hpp b/python/MeshHex8.hpp new file mode 100644 index 0000000..e7e944b --- /dev/null +++ b/python/MeshHex8.hpp @@ -0,0 +1,304 @@ +/* ================================================================================================= + +(c - GPLv3) T.W.J. de Geus (Tom) | tom@geus.me | www.geus.me | github.com/tdegeus/GooseFEM + +================================================================================================= */ + +#include + +#include +#include + +#include + +#include "../include/GooseFEM/GooseFEM.h" + +// ================================================================================================= + +namespace py = pybind11; + +// ================================================================================================= + +void init_MeshHex8(py::module &m) +{ + +py::class_(m, "Regular") + + .def(py::init(), "mesh with nx*ny*nz 'pixels' and edge size h", py::arg("nx"), py::arg("ny"), py::arg("nz"), py::arg("h")=1.) + + .def("nelem" , &GooseFEM::Mesh::Hex8::Regular::nelem ) + .def("nnode" , &GooseFEM::Mesh::Hex8::Regular::nnode ) + .def("nne" , &GooseFEM::Mesh::Hex8::Regular::nne ) + .def("ndim" , &GooseFEM::Mesh::Hex8::Regular::ndim ) + + .def("coor" , &GooseFEM::Mesh::Hex8::Regular::coor ) + .def("conn" , &GooseFEM::Mesh::Hex8::Regular::conn ) + + .def("nodesFront" , &GooseFEM::Mesh::Hex8::Regular::nodesFront ) + .def("nodesBack" , &GooseFEM::Mesh::Hex8::Regular::nodesBack ) + .def("nodesLeft" , &GooseFEM::Mesh::Hex8::Regular::nodesLeft ) + .def("nodesRight" , &GooseFEM::Mesh::Hex8::Regular::nodesRight ) + .def("nodesBottom" , &GooseFEM::Mesh::Hex8::Regular::nodesBottom ) + .def("nodesTop" , &GooseFEM::Mesh::Hex8::Regular::nodesTop ) + + .def("nodesFrontFace" , &GooseFEM::Mesh::Hex8::Regular::nodesFrontFace ) + .def("nodesBackFace" , &GooseFEM::Mesh::Hex8::Regular::nodesBackFace ) + .def("nodesLeftFace" , &GooseFEM::Mesh::Hex8::Regular::nodesLeftFace ) + .def("nodesRightFace" , &GooseFEM::Mesh::Hex8::Regular::nodesRightFace ) + .def("nodesBottomFace" , &GooseFEM::Mesh::Hex8::Regular::nodesBottomFace ) + .def("nodesTopFace" , &GooseFEM::Mesh::Hex8::Regular::nodesTopFace ) + + .def("nodesFrontBottomEdge" , &GooseFEM::Mesh::Hex8::Regular::nodesFrontBottomEdge ) + .def("nodesFrontTopEdge" , &GooseFEM::Mesh::Hex8::Regular::nodesFrontTopEdge ) + .def("nodesFrontLeftEdge" , &GooseFEM::Mesh::Hex8::Regular::nodesFrontLeftEdge ) + .def("nodesFrontRightEdge" , &GooseFEM::Mesh::Hex8::Regular::nodesFrontRightEdge ) + .def("nodesBackBottomEdge" , &GooseFEM::Mesh::Hex8::Regular::nodesBackBottomEdge ) + .def("nodesBackTopEdge" , &GooseFEM::Mesh::Hex8::Regular::nodesBackTopEdge ) + .def("nodesBackLeftEdge" , &GooseFEM::Mesh::Hex8::Regular::nodesBackLeftEdge ) + .def("nodesBackRightEdge" , &GooseFEM::Mesh::Hex8::Regular::nodesBackRightEdge ) + .def("nodesBottomLeftEdge" , &GooseFEM::Mesh::Hex8::Regular::nodesBottomLeftEdge ) + .def("nodesBottomRightEdge" , &GooseFEM::Mesh::Hex8::Regular::nodesBottomRightEdge ) + .def("nodesTopLeftEdge" , &GooseFEM::Mesh::Hex8::Regular::nodesTopLeftEdge ) + .def("nodesTopRightEdge" , &GooseFEM::Mesh::Hex8::Regular::nodesTopRightEdge ) + + .def("nodesBottomFrontEdge" , &GooseFEM::Mesh::Hex8::Regular::nodesBottomFrontEdge ) + .def("nodesBottomBackEdge" , &GooseFEM::Mesh::Hex8::Regular::nodesBottomBackEdge ) + .def("nodesTopFrontEdge" , &GooseFEM::Mesh::Hex8::Regular::nodesTopFrontEdge ) + .def("nodesTopBackEdge" , &GooseFEM::Mesh::Hex8::Regular::nodesTopBackEdge ) + .def("nodesLeftBottomEdge" , &GooseFEM::Mesh::Hex8::Regular::nodesLeftBottomEdge ) + .def("nodesLeftFrontEdge" , &GooseFEM::Mesh::Hex8::Regular::nodesLeftFrontEdge ) + .def("nodesLeftBackEdge" , &GooseFEM::Mesh::Hex8::Regular::nodesLeftBackEdge ) + .def("nodesLeftTopEdge" , &GooseFEM::Mesh::Hex8::Regular::nodesLeftTopEdge ) + .def("nodesRightBottomEdge" , &GooseFEM::Mesh::Hex8::Regular::nodesRightBottomEdge ) + .def("nodesRightTopEdge" , &GooseFEM::Mesh::Hex8::Regular::nodesRightTopEdge ) + .def("nodesRightFrontEdge" , &GooseFEM::Mesh::Hex8::Regular::nodesRightFrontEdge ) + .def("nodesRightBackEdge" , &GooseFEM::Mesh::Hex8::Regular::nodesRightBackEdge ) + + .def("nodesFrontBottomOpenEdge" , &GooseFEM::Mesh::Hex8::Regular::nodesFrontBottomOpenEdge ) + .def("nodesFrontTopOpenEdge" , &GooseFEM::Mesh::Hex8::Regular::nodesFrontTopOpenEdge ) + .def("nodesFrontLeftOpenEdge" , &GooseFEM::Mesh::Hex8::Regular::nodesFrontLeftOpenEdge ) + .def("nodesFrontRightOpenEdge" , &GooseFEM::Mesh::Hex8::Regular::nodesFrontRightOpenEdge ) + .def("nodesBackBottomOpenEdge" , &GooseFEM::Mesh::Hex8::Regular::nodesBackBottomOpenEdge ) + .def("nodesBackTopOpenEdge" , &GooseFEM::Mesh::Hex8::Regular::nodesBackTopOpenEdge ) + .def("nodesBackLeftOpenEdge" , &GooseFEM::Mesh::Hex8::Regular::nodesBackLeftOpenEdge ) + .def("nodesBackRightOpenEdge" , &GooseFEM::Mesh::Hex8::Regular::nodesBackRightOpenEdge ) + .def("nodesBottomLeftOpenEdge" , &GooseFEM::Mesh::Hex8::Regular::nodesBottomLeftOpenEdge ) + .def("nodesBottomRightOpenEdge" , &GooseFEM::Mesh::Hex8::Regular::nodesBottomRightOpenEdge ) + .def("nodesTopLeftOpenEdge" , &GooseFEM::Mesh::Hex8::Regular::nodesTopLeftOpenEdge ) + .def("nodesTopRightOpenEdge" , &GooseFEM::Mesh::Hex8::Regular::nodesTopRightOpenEdge ) + + .def("nodesBottomFrontOpenEdge" , &GooseFEM::Mesh::Hex8::Regular::nodesBottomFrontOpenEdge ) + .def("nodesBottomBackOpenEdge" , &GooseFEM::Mesh::Hex8::Regular::nodesBottomBackOpenEdge ) + .def("nodesTopFrontOpenEdge" , &GooseFEM::Mesh::Hex8::Regular::nodesTopFrontOpenEdge ) + .def("nodesTopBackOpenEdge" , &GooseFEM::Mesh::Hex8::Regular::nodesTopBackOpenEdge ) + .def("nodesLeftBottomOpenEdge" , &GooseFEM::Mesh::Hex8::Regular::nodesLeftBottomOpenEdge ) + .def("nodesLeftFrontOpenEdge" , &GooseFEM::Mesh::Hex8::Regular::nodesLeftFrontOpenEdge ) + .def("nodesLeftBackOpenEdge" , &GooseFEM::Mesh::Hex8::Regular::nodesLeftBackOpenEdge ) + .def("nodesLeftTopOpenEdge" , &GooseFEM::Mesh::Hex8::Regular::nodesLeftTopOpenEdge ) + .def("nodesRightBottomOpenEdge" , &GooseFEM::Mesh::Hex8::Regular::nodesRightBottomOpenEdge ) + .def("nodesRightTopOpenEdge" , &GooseFEM::Mesh::Hex8::Regular::nodesRightTopOpenEdge ) + .def("nodesRightFrontOpenEdge" , &GooseFEM::Mesh::Hex8::Regular::nodesRightFrontOpenEdge ) + .def("nodesRightBackOpenEdge" , &GooseFEM::Mesh::Hex8::Regular::nodesRightBackOpenEdge ) + + .def("nodesFrontBottomLeftCorner" , &GooseFEM::Mesh::Hex8::Regular::nodesFrontBottomLeftCorner ) + .def("nodesFrontBottomRightCorner", &GooseFEM::Mesh::Hex8::Regular::nodesFrontBottomRightCorner) + .def("nodesFrontTopLeftCorner" , &GooseFEM::Mesh::Hex8::Regular::nodesFrontTopLeftCorner ) + .def("nodesFrontTopRightCorner" , &GooseFEM::Mesh::Hex8::Regular::nodesFrontTopRightCorner ) + .def("nodesBackBottomLeftCorner" , &GooseFEM::Mesh::Hex8::Regular::nodesBackBottomLeftCorner ) + .def("nodesBackBottomRightCorner" , &GooseFEM::Mesh::Hex8::Regular::nodesBackBottomRightCorner ) + .def("nodesBackTopLeftCorner" , &GooseFEM::Mesh::Hex8::Regular::nodesBackTopLeftCorner ) + .def("nodesBackTopRightCorner" , &GooseFEM::Mesh::Hex8::Regular::nodesBackTopRightCorner ) + + .def("nodesFrontLeftBottomCorner" , &GooseFEM::Mesh::Hex8::Regular::nodesFrontLeftBottomCorner ) + .def("nodesBottomFrontLeftCorner" , &GooseFEM::Mesh::Hex8::Regular::nodesBottomFrontLeftCorner ) + .def("nodesBottomLeftFrontCorner" , &GooseFEM::Mesh::Hex8::Regular::nodesBottomLeftFrontCorner ) + .def("nodesLeftFrontBottomCorner" , &GooseFEM::Mesh::Hex8::Regular::nodesLeftFrontBottomCorner ) + .def("nodesLeftBottomFrontCorner" , &GooseFEM::Mesh::Hex8::Regular::nodesLeftBottomFrontCorner ) + .def("nodesFrontRightBottomCorner", &GooseFEM::Mesh::Hex8::Regular::nodesFrontRightBottomCorner) + .def("nodesBottomFrontRightCorner", &GooseFEM::Mesh::Hex8::Regular::nodesBottomFrontRightCorner) + .def("nodesBottomRightFrontCorner", &GooseFEM::Mesh::Hex8::Regular::nodesBottomRightFrontCorner) + .def("nodesRightFrontBottomCorner", &GooseFEM::Mesh::Hex8::Regular::nodesRightFrontBottomCorner) + .def("nodesRightBottomFrontCorner", &GooseFEM::Mesh::Hex8::Regular::nodesRightBottomFrontCorner) + .def("nodesFrontLeftTopCorner" , &GooseFEM::Mesh::Hex8::Regular::nodesFrontLeftTopCorner ) + .def("nodesTopFrontLeftCorner" , &GooseFEM::Mesh::Hex8::Regular::nodesTopFrontLeftCorner ) + .def("nodesTopLeftFrontCorner" , &GooseFEM::Mesh::Hex8::Regular::nodesTopLeftFrontCorner ) + .def("nodesLeftFrontTopCorner" , &GooseFEM::Mesh::Hex8::Regular::nodesLeftFrontTopCorner ) + .def("nodesLeftTopFrontCorner" , &GooseFEM::Mesh::Hex8::Regular::nodesLeftTopFrontCorner ) + .def("nodesFrontRightTopCorner" , &GooseFEM::Mesh::Hex8::Regular::nodesFrontRightTopCorner ) + .def("nodesTopFrontRightCorner" , &GooseFEM::Mesh::Hex8::Regular::nodesTopFrontRightCorner ) + .def("nodesTopRightFrontCorner" , &GooseFEM::Mesh::Hex8::Regular::nodesTopRightFrontCorner ) + .def("nodesRightFrontTopCorner" , &GooseFEM::Mesh::Hex8::Regular::nodesRightFrontTopCorner ) + .def("nodesRightTopFrontCorner" , &GooseFEM::Mesh::Hex8::Regular::nodesRightTopFrontCorner ) + .def("nodesBackLeftBottomCorner" , &GooseFEM::Mesh::Hex8::Regular::nodesBackLeftBottomCorner ) + .def("nodesBottomBackLeftCorner" , &GooseFEM::Mesh::Hex8::Regular::nodesBottomBackLeftCorner ) + .def("nodesBottomLeftBackCorner" , &GooseFEM::Mesh::Hex8::Regular::nodesBottomLeftBackCorner ) + .def("nodesLeftBackBottomCorner" , &GooseFEM::Mesh::Hex8::Regular::nodesLeftBackBottomCorner ) + .def("nodesLeftBottomBackCorner" , &GooseFEM::Mesh::Hex8::Regular::nodesLeftBottomBackCorner ) + .def("nodesBackRightBottomCorner" , &GooseFEM::Mesh::Hex8::Regular::nodesBackRightBottomCorner ) + .def("nodesBottomBackRightCorner" , &GooseFEM::Mesh::Hex8::Regular::nodesBottomBackRightCorner ) + .def("nodesBottomRightBackCorner" , &GooseFEM::Mesh::Hex8::Regular::nodesBottomRightBackCorner ) + .def("nodesRightBackBottomCorner" , &GooseFEM::Mesh::Hex8::Regular::nodesRightBackBottomCorner ) + .def("nodesRightBottomBackCorner" , &GooseFEM::Mesh::Hex8::Regular::nodesRightBottomBackCorner ) + .def("nodesBackLeftTopCorner" , &GooseFEM::Mesh::Hex8::Regular::nodesBackLeftTopCorner ) + .def("nodesTopBackLeftCorner" , &GooseFEM::Mesh::Hex8::Regular::nodesTopBackLeftCorner ) + .def("nodesTopLeftBackCorner" , &GooseFEM::Mesh::Hex8::Regular::nodesTopLeftBackCorner ) + .def("nodesLeftBackTopCorner" , &GooseFEM::Mesh::Hex8::Regular::nodesLeftBackTopCorner ) + .def("nodesLeftTopBackCorner" , &GooseFEM::Mesh::Hex8::Regular::nodesLeftTopBackCorner ) + .def("nodesBackRightTopCorner" , &GooseFEM::Mesh::Hex8::Regular::nodesBackRightTopCorner ) + .def("nodesTopBackRightCorner" , &GooseFEM::Mesh::Hex8::Regular::nodesTopBackRightCorner ) + .def("nodesTopRightBackCorner" , &GooseFEM::Mesh::Hex8::Regular::nodesTopRightBackCorner ) + .def("nodesRightBackTopCorner" , &GooseFEM::Mesh::Hex8::Regular::nodesRightBackTopCorner ) + .def("nodesRightTopBackCorner" , &GooseFEM::Mesh::Hex8::Regular::nodesRightTopBackCorner ) + + .def("nodesPeriodic" , &GooseFEM::Mesh::Hex8::Regular::nodesPeriodic ) + .def("nodesOrigin" , &GooseFEM::Mesh::Hex8::Regular::nodesOrigin ) + .def("dofs" , &GooseFEM::Mesh::Hex8::Regular::dofs ) + .def("dofsPeriodic" , &GooseFEM::Mesh::Hex8::Regular::dofsPeriodic ) + + .def("__repr__", [](const GooseFEM::Mesh::Hex8::Regular &){ return ""; }); + +// ------------------------------------------------------------------------------------------------- + +py::class_(m, "FineLayer") + + .def(py::init(), "mesh with nx*ny*nz 'pixels' and edge size h", py::arg("nx"), py::arg("ny"), py::arg("nz"), py::arg("h")=1., py::arg("nfine")=1) + + .def("nelem" , &GooseFEM::Mesh::Hex8::FineLayer::nelem ) + .def("nnode" , &GooseFEM::Mesh::Hex8::FineLayer::nnode ) + .def("nne" , &GooseFEM::Mesh::Hex8::FineLayer::nne ) + .def("ndim" , &GooseFEM::Mesh::Hex8::FineLayer::ndim ) + .def("shape" , &GooseFEM::Mesh::Hex8::FineLayer::shape ) + + .def("coor" , &GooseFEM::Mesh::Hex8::FineLayer::coor ) + .def("conn" , &GooseFEM::Mesh::Hex8::FineLayer::conn ) + + .def("elementsMiddleLayer" , &GooseFEM::Mesh::Hex8::FineLayer::elementsMiddleLayer ) + + .def("nodesFront" , &GooseFEM::Mesh::Hex8::FineLayer::nodesFront ) + .def("nodesBack" , &GooseFEM::Mesh::Hex8::FineLayer::nodesBack ) + .def("nodesLeft" , &GooseFEM::Mesh::Hex8::FineLayer::nodesLeft ) + .def("nodesRight" , &GooseFEM::Mesh::Hex8::FineLayer::nodesRight ) + .def("nodesBottom" , &GooseFEM::Mesh::Hex8::FineLayer::nodesBottom ) + .def("nodesTop" , &GooseFEM::Mesh::Hex8::FineLayer::nodesTop ) + + .def("nodesFrontFace" , &GooseFEM::Mesh::Hex8::FineLayer::nodesFrontFace ) + .def("nodesBackFace" , &GooseFEM::Mesh::Hex8::FineLayer::nodesBackFace ) + .def("nodesLeftFace" , &GooseFEM::Mesh::Hex8::FineLayer::nodesLeftFace ) + .def("nodesRightFace" , &GooseFEM::Mesh::Hex8::FineLayer::nodesRightFace ) + .def("nodesBottomFace" , &GooseFEM::Mesh::Hex8::FineLayer::nodesBottomFace ) + .def("nodesTopFace" , &GooseFEM::Mesh::Hex8::FineLayer::nodesTopFace ) + + .def("nodesFrontBottomEdge" , &GooseFEM::Mesh::Hex8::FineLayer::nodesFrontBottomEdge ) + .def("nodesFrontTopEdge" , &GooseFEM::Mesh::Hex8::FineLayer::nodesFrontTopEdge ) + .def("nodesFrontLeftEdge" , &GooseFEM::Mesh::Hex8::FineLayer::nodesFrontLeftEdge ) + .def("nodesFrontRightEdge" , &GooseFEM::Mesh::Hex8::FineLayer::nodesFrontRightEdge ) + .def("nodesBackBottomEdge" , &GooseFEM::Mesh::Hex8::FineLayer::nodesBackBottomEdge ) + .def("nodesBackTopEdge" , &GooseFEM::Mesh::Hex8::FineLayer::nodesBackTopEdge ) + .def("nodesBackLeftEdge" , &GooseFEM::Mesh::Hex8::FineLayer::nodesBackLeftEdge ) + .def("nodesBackRightEdge" , &GooseFEM::Mesh::Hex8::FineLayer::nodesBackRightEdge ) + .def("nodesBottomLeftEdge" , &GooseFEM::Mesh::Hex8::FineLayer::nodesBottomLeftEdge ) + .def("nodesBottomRightEdge" , &GooseFEM::Mesh::Hex8::FineLayer::nodesBottomRightEdge ) + .def("nodesTopLeftEdge" , &GooseFEM::Mesh::Hex8::FineLayer::nodesTopLeftEdge ) + .def("nodesTopRightEdge" , &GooseFEM::Mesh::Hex8::FineLayer::nodesTopRightEdge ) + + .def("nodesBottomFrontEdge" , &GooseFEM::Mesh::Hex8::FineLayer::nodesBottomFrontEdge ) + .def("nodesBottomBackEdge" , &GooseFEM::Mesh::Hex8::FineLayer::nodesBottomBackEdge ) + .def("nodesTopFrontEdge" , &GooseFEM::Mesh::Hex8::FineLayer::nodesTopFrontEdge ) + .def("nodesTopBackEdge" , &GooseFEM::Mesh::Hex8::FineLayer::nodesTopBackEdge ) + .def("nodesLeftBottomEdge" , &GooseFEM::Mesh::Hex8::FineLayer::nodesLeftBottomEdge ) + .def("nodesLeftFrontEdge" , &GooseFEM::Mesh::Hex8::FineLayer::nodesLeftFrontEdge ) + .def("nodesLeftBackEdge" , &GooseFEM::Mesh::Hex8::FineLayer::nodesLeftBackEdge ) + .def("nodesLeftTopEdge" , &GooseFEM::Mesh::Hex8::FineLayer::nodesLeftTopEdge ) + .def("nodesRightBottomEdge" , &GooseFEM::Mesh::Hex8::FineLayer::nodesRightBottomEdge ) + .def("nodesRightTopEdge" , &GooseFEM::Mesh::Hex8::FineLayer::nodesRightTopEdge ) + .def("nodesRightFrontEdge" , &GooseFEM::Mesh::Hex8::FineLayer::nodesRightFrontEdge ) + .def("nodesRightBackEdge" , &GooseFEM::Mesh::Hex8::FineLayer::nodesRightBackEdge ) + + .def("nodesFrontBottomOpenEdge" , &GooseFEM::Mesh::Hex8::FineLayer::nodesFrontBottomOpenEdge ) + .def("nodesFrontTopOpenEdge" , &GooseFEM::Mesh::Hex8::FineLayer::nodesFrontTopOpenEdge ) + .def("nodesFrontLeftOpenEdge" , &GooseFEM::Mesh::Hex8::FineLayer::nodesFrontLeftOpenEdge ) + .def("nodesFrontRightOpenEdge" , &GooseFEM::Mesh::Hex8::FineLayer::nodesFrontRightOpenEdge ) + .def("nodesBackBottomOpenEdge" , &GooseFEM::Mesh::Hex8::FineLayer::nodesBackBottomOpenEdge ) + .def("nodesBackTopOpenEdge" , &GooseFEM::Mesh::Hex8::FineLayer::nodesBackTopOpenEdge ) + .def("nodesBackLeftOpenEdge" , &GooseFEM::Mesh::Hex8::FineLayer::nodesBackLeftOpenEdge ) + .def("nodesBackRightOpenEdge" , &GooseFEM::Mesh::Hex8::FineLayer::nodesBackRightOpenEdge ) + .def("nodesBottomLeftOpenEdge" , &GooseFEM::Mesh::Hex8::FineLayer::nodesBottomLeftOpenEdge ) + .def("nodesBottomRightOpenEdge" , &GooseFEM::Mesh::Hex8::FineLayer::nodesBottomRightOpenEdge ) + .def("nodesTopLeftOpenEdge" , &GooseFEM::Mesh::Hex8::FineLayer::nodesTopLeftOpenEdge ) + .def("nodesTopRightOpenEdge" , &GooseFEM::Mesh::Hex8::FineLayer::nodesTopRightOpenEdge ) + + .def("nodesBottomFrontOpenEdge" , &GooseFEM::Mesh::Hex8::FineLayer::nodesBottomFrontOpenEdge ) + .def("nodesBottomBackOpenEdge" , &GooseFEM::Mesh::Hex8::FineLayer::nodesBottomBackOpenEdge ) + .def("nodesTopFrontOpenEdge" , &GooseFEM::Mesh::Hex8::FineLayer::nodesTopFrontOpenEdge ) + .def("nodesTopBackOpenEdge" , &GooseFEM::Mesh::Hex8::FineLayer::nodesTopBackOpenEdge ) + .def("nodesLeftBottomOpenEdge" , &GooseFEM::Mesh::Hex8::FineLayer::nodesLeftBottomOpenEdge ) + .def("nodesLeftFrontOpenEdge" , &GooseFEM::Mesh::Hex8::FineLayer::nodesLeftFrontOpenEdge ) + .def("nodesLeftBackOpenEdge" , &GooseFEM::Mesh::Hex8::FineLayer::nodesLeftBackOpenEdge ) + .def("nodesLeftTopOpenEdge" , &GooseFEM::Mesh::Hex8::FineLayer::nodesLeftTopOpenEdge ) + .def("nodesRightBottomOpenEdge" , &GooseFEM::Mesh::Hex8::FineLayer::nodesRightBottomOpenEdge ) + .def("nodesRightTopOpenEdge" , &GooseFEM::Mesh::Hex8::FineLayer::nodesRightTopOpenEdge ) + .def("nodesRightFrontOpenEdge" , &GooseFEM::Mesh::Hex8::FineLayer::nodesRightFrontOpenEdge ) + .def("nodesRightBackOpenEdge" , &GooseFEM::Mesh::Hex8::FineLayer::nodesRightBackOpenEdge ) + + .def("nodesFrontBottomLeftCorner" , &GooseFEM::Mesh::Hex8::FineLayer::nodesFrontBottomLeftCorner ) + .def("nodesFrontBottomRightCorner", &GooseFEM::Mesh::Hex8::FineLayer::nodesFrontBottomRightCorner) + .def("nodesFrontTopLeftCorner" , &GooseFEM::Mesh::Hex8::FineLayer::nodesFrontTopLeftCorner ) + .def("nodesFrontTopRightCorner" , &GooseFEM::Mesh::Hex8::FineLayer::nodesFrontTopRightCorner ) + .def("nodesBackBottomLeftCorner" , &GooseFEM::Mesh::Hex8::FineLayer::nodesBackBottomLeftCorner ) + .def("nodesBackBottomRightCorner" , &GooseFEM::Mesh::Hex8::FineLayer::nodesBackBottomRightCorner ) + .def("nodesBackTopLeftCorner" , &GooseFEM::Mesh::Hex8::FineLayer::nodesBackTopLeftCorner ) + .def("nodesBackTopRightCorner" , &GooseFEM::Mesh::Hex8::FineLayer::nodesBackTopRightCorner ) + + .def("nodesFrontLeftBottomCorner" , &GooseFEM::Mesh::Hex8::FineLayer::nodesFrontLeftBottomCorner ) + .def("nodesBottomFrontLeftCorner" , &GooseFEM::Mesh::Hex8::FineLayer::nodesBottomFrontLeftCorner ) + .def("nodesBottomLeftFrontCorner" , &GooseFEM::Mesh::Hex8::FineLayer::nodesBottomLeftFrontCorner ) + .def("nodesLeftFrontBottomCorner" , &GooseFEM::Mesh::Hex8::FineLayer::nodesLeftFrontBottomCorner ) + .def("nodesLeftBottomFrontCorner" , &GooseFEM::Mesh::Hex8::FineLayer::nodesLeftBottomFrontCorner ) + .def("nodesFrontRightBottomCorner", &GooseFEM::Mesh::Hex8::FineLayer::nodesFrontRightBottomCorner) + .def("nodesBottomFrontRightCorner", &GooseFEM::Mesh::Hex8::FineLayer::nodesBottomFrontRightCorner) + .def("nodesBottomRightFrontCorner", &GooseFEM::Mesh::Hex8::FineLayer::nodesBottomRightFrontCorner) + .def("nodesRightFrontBottomCorner", &GooseFEM::Mesh::Hex8::FineLayer::nodesRightFrontBottomCorner) + .def("nodesRightBottomFrontCorner", &GooseFEM::Mesh::Hex8::FineLayer::nodesRightBottomFrontCorner) + .def("nodesFrontLeftTopCorner" , &GooseFEM::Mesh::Hex8::FineLayer::nodesFrontLeftTopCorner ) + .def("nodesTopFrontLeftCorner" , &GooseFEM::Mesh::Hex8::FineLayer::nodesTopFrontLeftCorner ) + .def("nodesTopLeftFrontCorner" , &GooseFEM::Mesh::Hex8::FineLayer::nodesTopLeftFrontCorner ) + .def("nodesLeftFrontTopCorner" , &GooseFEM::Mesh::Hex8::FineLayer::nodesLeftFrontTopCorner ) + .def("nodesLeftTopFrontCorner" , &GooseFEM::Mesh::Hex8::FineLayer::nodesLeftTopFrontCorner ) + .def("nodesFrontRightTopCorner" , &GooseFEM::Mesh::Hex8::FineLayer::nodesFrontRightTopCorner ) + .def("nodesTopFrontRightCorner" , &GooseFEM::Mesh::Hex8::FineLayer::nodesTopFrontRightCorner ) + .def("nodesTopRightFrontCorner" , &GooseFEM::Mesh::Hex8::FineLayer::nodesTopRightFrontCorner ) + .def("nodesRightFrontTopCorner" , &GooseFEM::Mesh::Hex8::FineLayer::nodesRightFrontTopCorner ) + .def("nodesRightTopFrontCorner" , &GooseFEM::Mesh::Hex8::FineLayer::nodesRightTopFrontCorner ) + .def("nodesBackLeftBottomCorner" , &GooseFEM::Mesh::Hex8::FineLayer::nodesBackLeftBottomCorner ) + .def("nodesBottomBackLeftCorner" , &GooseFEM::Mesh::Hex8::FineLayer::nodesBottomBackLeftCorner ) + .def("nodesBottomLeftBackCorner" , &GooseFEM::Mesh::Hex8::FineLayer::nodesBottomLeftBackCorner ) + .def("nodesLeftBackBottomCorner" , &GooseFEM::Mesh::Hex8::FineLayer::nodesLeftBackBottomCorner ) + .def("nodesLeftBottomBackCorner" , &GooseFEM::Mesh::Hex8::FineLayer::nodesLeftBottomBackCorner ) + .def("nodesBackRightBottomCorner" , &GooseFEM::Mesh::Hex8::FineLayer::nodesBackRightBottomCorner ) + .def("nodesBottomBackRightCorner" , &GooseFEM::Mesh::Hex8::FineLayer::nodesBottomBackRightCorner ) + .def("nodesBottomRightBackCorner" , &GooseFEM::Mesh::Hex8::FineLayer::nodesBottomRightBackCorner ) + .def("nodesRightBackBottomCorner" , &GooseFEM::Mesh::Hex8::FineLayer::nodesRightBackBottomCorner ) + .def("nodesRightBottomBackCorner" , &GooseFEM::Mesh::Hex8::FineLayer::nodesRightBottomBackCorner ) + .def("nodesBackLeftTopCorner" , &GooseFEM::Mesh::Hex8::FineLayer::nodesBackLeftTopCorner ) + .def("nodesTopBackLeftCorner" , &GooseFEM::Mesh::Hex8::FineLayer::nodesTopBackLeftCorner ) + .def("nodesTopLeftBackCorner" , &GooseFEM::Mesh::Hex8::FineLayer::nodesTopLeftBackCorner ) + .def("nodesLeftBackTopCorner" , &GooseFEM::Mesh::Hex8::FineLayer::nodesLeftBackTopCorner ) + .def("nodesLeftTopBackCorner" , &GooseFEM::Mesh::Hex8::FineLayer::nodesLeftTopBackCorner ) + .def("nodesBackRightTopCorner" , &GooseFEM::Mesh::Hex8::FineLayer::nodesBackRightTopCorner ) + .def("nodesTopBackRightCorner" , &GooseFEM::Mesh::Hex8::FineLayer::nodesTopBackRightCorner ) + .def("nodesTopRightBackCorner" , &GooseFEM::Mesh::Hex8::FineLayer::nodesTopRightBackCorner ) + .def("nodesRightBackTopCorner" , &GooseFEM::Mesh::Hex8::FineLayer::nodesRightBackTopCorner ) + .def("nodesRightTopBackCorner" , &GooseFEM::Mesh::Hex8::FineLayer::nodesRightTopBackCorner ) + + .def("nodesPeriodic" , &GooseFEM::Mesh::Hex8::FineLayer::nodesPeriodic ) + .def("nodesOrigin" , &GooseFEM::Mesh::Hex8::FineLayer::nodesOrigin ) + + .def("dofs" , &GooseFEM::Mesh::Hex8::FineLayer::dofs ) + .def("dofsPeriodic" , &GooseFEM::Mesh::Hex8::FineLayer::dofsPeriodic ) + + .def("__repr__", [](const GooseFEM::Mesh::Hex8::FineLayer &){ return ""; }); + +} + +// ================================================================================================= + diff --git a/python/MeshQuad4.hpp b/python/MeshQuad4.hpp new file mode 100644 index 0000000..d912408 --- /dev/null +++ b/python/MeshQuad4.hpp @@ -0,0 +1,111 @@ +/* ================================================================================================= + +(c - GPLv3) T.W.J. de Geus (Tom) | tom@geus.me | www.geus.me | github.com/tdegeus/GooseFEM + +================================================================================================= */ + +#include + +#include +#include + +#include + +#include "../include/GooseFEM/GooseFEM.h" + +// ================================================================================================= + +namespace py = pybind11; + +// ================================================================================================= + +void init_MeshQuad4(py::module &m) +{ + +py::class_(m, "Regular") + + .def(py::init(), "Regular mesh: 'nx' pixels in horizontal direction, 'ny' in vertical direction, edge size 'h'", py::arg("nx"), py::arg("ny"), py::arg("h")=1.) + + .def("coor" , &GooseFEM::Mesh::Quad4::Regular::coor ) + .def("conn" , &GooseFEM::Mesh::Quad4::Regular::conn ) + .def("nelem" , &GooseFEM::Mesh::Quad4::Regular::nelem ) + .def("nnode" , &GooseFEM::Mesh::Quad4::Regular::nnode ) + .def("nne" , &GooseFEM::Mesh::Quad4::Regular::nne ) + .def("ndim" , &GooseFEM::Mesh::Quad4::Regular::ndim ) + + .def("nodesBottomEdge" , &GooseFEM::Mesh::Quad4::Regular::nodesBottomEdge ) + .def("nodesTopEdge" , &GooseFEM::Mesh::Quad4::Regular::nodesTopEdge ) + .def("nodesLeftEdge" , &GooseFEM::Mesh::Quad4::Regular::nodesLeftEdge ) + .def("nodesRightEdge" , &GooseFEM::Mesh::Quad4::Regular::nodesRightEdge ) + .def("nodesBottomOpenEdge" , &GooseFEM::Mesh::Quad4::Regular::nodesBottomOpenEdge ) + .def("nodesTopOpenEdge" , &GooseFEM::Mesh::Quad4::Regular::nodesTopOpenEdge ) + .def("nodesLeftOpenEdge" , &GooseFEM::Mesh::Quad4::Regular::nodesLeftOpenEdge ) + .def("nodesRightOpenEdge" , &GooseFEM::Mesh::Quad4::Regular::nodesRightOpenEdge ) + + .def("nodesBottomLeftCorner" , &GooseFEM::Mesh::Quad4::Regular::nodesBottomLeftCorner ) + .def("nodesBottomRightCorner", &GooseFEM::Mesh::Quad4::Regular::nodesBottomRightCorner) + .def("nodesTopLeftCorner" , &GooseFEM::Mesh::Quad4::Regular::nodesTopLeftCorner ) + .def("nodesTopRightCorner" , &GooseFEM::Mesh::Quad4::Regular::nodesTopRightCorner ) + .def("nodesLeftBottomCorner" , &GooseFEM::Mesh::Quad4::Regular::nodesLeftBottomCorner ) + .def("nodesLeftTopCorner" , &GooseFEM::Mesh::Quad4::Regular::nodesLeftTopCorner ) + .def("nodesRightBottomCorner", &GooseFEM::Mesh::Quad4::Regular::nodesRightBottomCorner) + .def("nodesRightTopCorner" , &GooseFEM::Mesh::Quad4::Regular::nodesRightTopCorner ) + + .def("nodesPeriodic" , &GooseFEM::Mesh::Quad4::Regular::nodesPeriodic ) + .def("nodesOrigin" , &GooseFEM::Mesh::Quad4::Regular::nodesOrigin ) + + .def("dofs" , &GooseFEM::Mesh::Quad4::Regular::dofs ) + .def("dofsPeriodic" , &GooseFEM::Mesh::Quad4::Regular::dofsPeriodic ) + + .def("__repr__", [](const GooseFEM::Mesh::Quad4::Regular &){ return ""; }); + +// ------------------------------------------------------------------------------------------------- + +py::class_(m, "FineLayer") + + .def( + py::init(), + "FineLayer mesh: 'nx' pixels in horizontal direction (length 'Lx'), idem in vertical direction", + py::arg("nx"), + py::arg("ny"), + py::arg("h")=1., + py::arg("nfine")=1 + ) + + .def("shape" , &GooseFEM::Mesh::Quad4::FineLayer::shape ) + .def("coor" , &GooseFEM::Mesh::Quad4::FineLayer::coor ) + .def("conn" , &GooseFEM::Mesh::Quad4::FineLayer::conn ) + .def("nelem" , &GooseFEM::Mesh::Quad4::FineLayer::nelem ) + .def("nnode" , &GooseFEM::Mesh::Quad4::FineLayer::nnode ) + .def("nne" , &GooseFEM::Mesh::Quad4::FineLayer::nne ) + .def("ndim" , &GooseFEM::Mesh::Quad4::FineLayer::ndim ) + .def("elementsMiddleLayer" , &GooseFEM::Mesh::Quad4::FineLayer::elementsMiddleLayer ) + .def("nodesBottomEdge" , &GooseFEM::Mesh::Quad4::FineLayer::nodesBottomEdge ) + .def("nodesTopEdge" , &GooseFEM::Mesh::Quad4::FineLayer::nodesTopEdge ) + .def("nodesLeftEdge" , &GooseFEM::Mesh::Quad4::FineLayer::nodesLeftEdge ) + .def("nodesRightEdge" , &GooseFEM::Mesh::Quad4::FineLayer::nodesRightEdge ) + .def("nodesBottomOpenEdge" , &GooseFEM::Mesh::Quad4::FineLayer::nodesBottomOpenEdge ) + .def("nodesTopOpenEdge" , &GooseFEM::Mesh::Quad4::FineLayer::nodesTopOpenEdge ) + .def("nodesLeftOpenEdge" , &GooseFEM::Mesh::Quad4::FineLayer::nodesLeftOpenEdge ) + .def("nodesRightOpenEdge" , &GooseFEM::Mesh::Quad4::FineLayer::nodesRightOpenEdge ) + .def("nodesBottomLeftCorner" , &GooseFEM::Mesh::Quad4::FineLayer::nodesBottomLeftCorner ) + .def("nodesBottomRightCorner", &GooseFEM::Mesh::Quad4::FineLayer::nodesBottomRightCorner) + .def("nodesTopLeftCorner" , &GooseFEM::Mesh::Quad4::FineLayer::nodesTopLeftCorner ) + .def("nodesTopRightCorner" , &GooseFEM::Mesh::Quad4::FineLayer::nodesTopRightCorner ) + .def("nodesLeftBottomCorner" , &GooseFEM::Mesh::Quad4::FineLayer::nodesLeftBottomCorner ) + .def("nodesLeftTopCorner" , &GooseFEM::Mesh::Quad4::FineLayer::nodesLeftTopCorner ) + .def("nodesRightBottomCorner", &GooseFEM::Mesh::Quad4::FineLayer::nodesRightBottomCorner) + .def("nodesRightTopCorner" , &GooseFEM::Mesh::Quad4::FineLayer::nodesRightTopCorner ) + .def("nodesPeriodic" , &GooseFEM::Mesh::Quad4::FineLayer::nodesPeriodic ) + .def("nodesOrigin" , &GooseFEM::Mesh::Quad4::FineLayer::nodesOrigin ) + .def("dofs" , &GooseFEM::Mesh::Quad4::FineLayer::dofs ) + .def("dofsPeriodic" , &GooseFEM::Mesh::Quad4::FineLayer::dofsPeriodic ) + + .def("__repr__", + [](const GooseFEM::Mesh::Quad4::FineLayer &){ return ""; } + ); + +} + +// ================================================================================================= + diff --git a/python/MeshTri3.hpp b/python/MeshTri3.hpp new file mode 100644 index 0000000..f574d51 --- /dev/null +++ b/python/MeshTri3.hpp @@ -0,0 +1,77 @@ +/* ================================================================================================= + +(c - GPLv3) T.W.J. de Geus (Tom) | tom@geus.me | www.geus.me | github.com/tdegeus/GooseFEM + +================================================================================================= */ + +#include + +#include +#include + +#include + +#include "../include/GooseFEM/GooseFEM.h" + +// ================================================================================================= + +namespace py = pybind11; + +// ================================================================================================= + +void init_MeshTri3(py::module &m) +{ + +py::class_(m, "Regular") + + .def( + py::init(), + "Regular mesh: 'nx' pixels in horizontal direction, 'ny' in vertical direction, edge size 'h'", + py::arg("nx"), + py::arg("ny"), + py::arg("h")=1. + ) + + .def("coor" , &GooseFEM::Mesh::Tri3::Regular::coor ) + .def("conn" , &GooseFEM::Mesh::Tri3::Regular::conn ) + .def("nelem" , &GooseFEM::Mesh::Tri3::Regular::nelem ) + .def("nnode" , &GooseFEM::Mesh::Tri3::Regular::nnode ) + .def("nne" , &GooseFEM::Mesh::Tri3::Regular::nne ) + .def("ndim" , &GooseFEM::Mesh::Tri3::Regular::ndim ) + + .def("nodesBottomEdge" , &GooseFEM::Mesh::Tri3::Regular::nodesBottomEdge ) + .def("nodesTopEdge" , &GooseFEM::Mesh::Tri3::Regular::nodesTopEdge ) + .def("nodesLeftEdge" , &GooseFEM::Mesh::Tri3::Regular::nodesLeftEdge ) + .def("nodesRightEdge" , &GooseFEM::Mesh::Tri3::Regular::nodesRightEdge ) + .def("nodesBottomOpenEdge" , &GooseFEM::Mesh::Tri3::Regular::nodesBottomOpenEdge ) + .def("nodesTopOpenEdge" , &GooseFEM::Mesh::Tri3::Regular::nodesTopOpenEdge ) + .def("nodesLeftOpenEdge" , &GooseFEM::Mesh::Tri3::Regular::nodesLeftOpenEdge ) + .def("nodesRightOpenEdge" , &GooseFEM::Mesh::Tri3::Regular::nodesRightOpenEdge ) + + .def("nodesBottomLeftCorner" , &GooseFEM::Mesh::Tri3::Regular::nodesBottomLeftCorner ) + .def("nodesBottomRightCorner", &GooseFEM::Mesh::Tri3::Regular::nodesBottomRightCorner) + .def("nodesTopLeftCorner" , &GooseFEM::Mesh::Tri3::Regular::nodesTopLeftCorner ) + .def("nodesTopRightCorner" , &GooseFEM::Mesh::Tri3::Regular::nodesTopRightCorner ) + .def("nodesLeftBottomCorner" , &GooseFEM::Mesh::Tri3::Regular::nodesLeftBottomCorner ) + .def("nodesLeftTopCorner" , &GooseFEM::Mesh::Tri3::Regular::nodesLeftTopCorner ) + .def("nodesRightBottomCorner", &GooseFEM::Mesh::Tri3::Regular::nodesRightBottomCorner) + .def("nodesRightTopCorner" , &GooseFEM::Mesh::Tri3::Regular::nodesRightTopCorner ) + + .def("nodesPeriodic" , &GooseFEM::Mesh::Tri3::Regular::nodesPeriodic ) + .def("nodesOrigin" , &GooseFEM::Mesh::Tri3::Regular::nodesOrigin ) + + .def("dofs" , &GooseFEM::Mesh::Tri3::Regular::dofs ) + .def("dofsPeriodic" , &GooseFEM::Mesh::Tri3::Regular::dofsPeriodic ) + + .def("__repr__", [](const GooseFEM::Mesh::Tri3::Regular &){ return ""; }); + +// ------------------------------------------------------------------------------------------------- + +m.def("getOrientation", &GooseFEM::Mesh::Tri3::getOrientation, "Get the orientation of each element", py::arg("coor"), py::arg("conn")); + +m.def("retriangulate", &GooseFEM::Mesh::Tri3::retriangulate, "Re-triangulate existing mesh", py::arg("coor"), py::arg("conn"), py::arg("orientation")=-1); + +} + +// ================================================================================================= + diff --git a/python/Vector.hpp b/python/Vector.hpp new file mode 100644 index 0000000..36949d5 --- /dev/null +++ b/python/Vector.hpp @@ -0,0 +1,55 @@ +/* ================================================================================================= + +(c - GPLv3) T.W.J. de Geus (Tom) | tom@geus.me | www.geus.me | github.com/tdegeus/GooseFEM + +================================================================================================= */ + +#include + +#include +#include + +#include + +#include "../include/GooseFEM/GooseFEM.h" + +// ================================================================================================= + +namespace py = pybind11; + +// ================================================================================================= + +void init_Vector(py::module &m) +{ + +py::class_(m, "Vector") + + .def(py::init &, const xt::xtensor &>(), "Switch between dofval/nodevec/elemvec", py::arg("conn"), py::arg("dofs")) + + .def("nelem", &GooseFEM::Vector::nelem, "Return number of element") + .def("nne" , &GooseFEM::Vector::nne , "Return number of nodes per element") + .def("nnode", &GooseFEM::Vector::nnode, "Return number of nodes") + .def("ndim" , &GooseFEM::Vector::ndim , "Return number of dimensions") + .def("ndof" , &GooseFEM::Vector::ndof , "Return number of degrees-of-freedom") + .def("dofs" , &GooseFEM::Vector::dofs , "Return degrees-of-freedom") + + .def("asDofs", py::overload_cast&>(&GooseFEM::Vector::asDofs, py::const_), "Set 'dofval", py::arg("nodevec")) + .def("asDofs", py::overload_cast&>(&GooseFEM::Vector::asDofs, py::const_), "Set 'dofval", py::arg("elemvec")) + + .def("asNode", py::overload_cast&>(&GooseFEM::Vector::asNode, py::const_), "Set 'nodevec", py::arg("dofval")) + .def("asNode", py::overload_cast&>(&GooseFEM::Vector::asNode, py::const_), "Set 'nodevec", py::arg("elemvec")) + + .def("asElement", py::overload_cast&>(&GooseFEM::Vector::asElement, py::const_), "Set 'elemvec", py::arg("dofval")) + .def("asElement", py::overload_cast&>(&GooseFEM::Vector::asElement, py::const_), "Set 'elemvec", py::arg("nodevec")) + + .def("assembleDofs", py::overload_cast&>(&GooseFEM::Vector::assembleDofs, py::const_), "Assemble 'dofval'", py::arg("nodevec")) + .def("assembleDofs", py::overload_cast&>(&GooseFEM::Vector::assembleDofs, py::const_), "Assemble 'dofval'", py::arg("elemvec")) + + .def("assembleNode", py::overload_cast&>(&GooseFEM::Vector::assembleNode, py::const_), "Assemble 'nodevec'", py::arg("elemvec")) + + .def("__repr__", [](const GooseFEM::Vector &){ return ""; }); + +} + +// ================================================================================================= + diff --git a/python/VectorPartitioned.hpp b/python/VectorPartitioned.hpp new file mode 100644 index 0000000..c31a630 --- /dev/null +++ b/python/VectorPartitioned.hpp @@ -0,0 +1,72 @@ +/* ================================================================================================= + +(c - GPLv3) T.W.J. de Geus (Tom) | tom@geus.me | www.geus.me | github.com/tdegeus/GooseFEM + +================================================================================================= */ + +#include + +#include +#include + +#include + +#include "../include/GooseFEM/GooseFEM.h" + +// ================================================================================================= + +namespace py = pybind11; + +// ================================================================================================= + +void init_VectorPartitioned(py::module &m) +{ + +py::class_(m, "VectorPartitioned") + + .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", &GooseFEM::VectorPartitioned::nelem, "Return number of element") + .def("nne" , &GooseFEM::VectorPartitioned::nne , "Return number of nodes per element") + .def("nnode", &GooseFEM::VectorPartitioned::nnode, "Return number of nodes") + .def("ndim" , &GooseFEM::VectorPartitioned::ndim , "Return number of dimensions") + .def("ndof" , &GooseFEM::VectorPartitioned::ndof , "Return number of degrees-of-freedom") + .def("nnu" , &GooseFEM::VectorPartitioned::nnu , "Return number of unknown degrees-of-freedom") + .def("nnp" , &GooseFEM::VectorPartitioned::nnp , "Return number of prescribed degrees-of-freedom") + + .def("dofs" , &GooseFEM::VectorPartitioned::dofs , "Return degrees-of-freedom") + .def("iiu" , &GooseFEM::VectorPartitioned::iiu , "Return unknown degrees-of-freedom") + .def("iip" , &GooseFEM::VectorPartitioned::iip , "Return prescribed degrees-of-freedom") + + .def("asDofs", py::overload_cast&,const xt::xtensor&>(&GooseFEM::VectorPartitioned::asDofs, py::const_), "Set 'dofval" , py::arg("dofval_u"), py::arg("dofval_p")) + .def("asDofs", py::overload_cast& >(&GooseFEM::VectorPartitioned::asDofs, py::const_), "Set 'dofval" , py::arg("nodevec")) + .def("asDofs", py::overload_cast& >(&GooseFEM::VectorPartitioned::asDofs, py::const_), "Set 'dofval" , py::arg("elemvec")) + + .def("asDofs_u", py::overload_cast&>(&GooseFEM::VectorPartitioned::asDofs_u , py::const_), "Set 'dofval" , py::arg("nodevec")) + .def("asDofs_u", py::overload_cast&>(&GooseFEM::VectorPartitioned::asDofs_u , py::const_), "Set 'dofval" , py::arg("elemvec")) + .def("asDofs_p", py::overload_cast&>(&GooseFEM::VectorPartitioned::asDofs_p , py::const_), "Set 'dofval" , py::arg("nodevec")) + .def("asDofs_p", py::overload_cast&>(&GooseFEM::VectorPartitioned::asDofs_p , py::const_), "Set 'dofval" , py::arg("elemvec")) + + .def("asNode", py::overload_cast&,const xt::xtensor&>(&GooseFEM::VectorPartitioned::asNode, py::const_), "Set 'nodevec", py::arg("dofval_u"), py::arg("dofval_p")) + .def("asNode", py::overload_cast& >(&GooseFEM::VectorPartitioned::asNode, py::const_), "Set 'nodevec", py::arg("dofval")) + .def("asNode", py::overload_cast& >(&GooseFEM::VectorPartitioned::asNode, py::const_), "Set 'nodevec", py::arg("elemvec")) + + .def("asElement", py::overload_cast&,const xt::xtensor&>(&GooseFEM::VectorPartitioned::asElement, py::const_), "Set 'elemvec", py::arg("dofval_u"), py::arg("dofval_p")) + .def("asElement", py::overload_cast& >(&GooseFEM::VectorPartitioned::asElement, py::const_), "Set 'elemvec", py::arg("dofval")) + .def("asElement", py::overload_cast& >(&GooseFEM::VectorPartitioned::asElement, py::const_), "Set 'elemvec", py::arg("nodevec")) + + .def("assembleDofs" , py::overload_cast&>(&GooseFEM::VectorPartitioned::assembleDofs , py::const_), "Assemble 'dofval'" , py::arg("nodevec")) + .def("assembleDofs" , py::overload_cast&>(&GooseFEM::VectorPartitioned::assembleDofs , py::const_), "Assemble 'dofval'" , py::arg("elemvec")) + .def("assembleDofs_u", py::overload_cast&>(&GooseFEM::VectorPartitioned::assembleDofs_u, py::const_), "Assemble 'dofval'" , py::arg("nodevec")) + .def("assembleDofs_u", py::overload_cast&>(&GooseFEM::VectorPartitioned::assembleDofs_u, py::const_), "Assemble 'dofval'" , py::arg("elemvec")) + .def("assembleDofs_p", py::overload_cast&>(&GooseFEM::VectorPartitioned::assembleDofs_p, py::const_), "Assemble 'dofval'" , py::arg("nodevec")) + .def("assembleDofs_p", py::overload_cast&>(&GooseFEM::VectorPartitioned::assembleDofs_p, py::const_), "Assemble 'dofval'" , py::arg("elemvec")) + + .def("assembleNode" , py::overload_cast&>(&GooseFEM::VectorPartitioned::assembleNode , py::const_), "Assemble 'nodevec'", py::arg("elemvec")) + + .def("__repr__", [](const GooseFEM::VectorPartitioned &){ return ""; }); + +} + +// ================================================================================================= + diff --git a/python/main.cpp b/python/main.cpp new file mode 100644 index 0000000..c20a8cb --- /dev/null +++ b/python/main.cpp @@ -0,0 +1,114 @@ +/* ================================================================================================= + +(c - GPLv3) T.W.J. de Geus (Tom) | tom@geus.me | www.geus.me | github.com/tdegeus/GooseFEM + +================================================================================================= */ + +#include + +#include +#include + +#include + +#include "../include/GooseFEM/GooseFEM.h" + +// ================================================================================================= + +namespace py = pybind11; + +// ================================================================================================= + +#include "Vector.hpp" +#include "VectorPartitioned.hpp" +#include "MatrixDiagonalPartitioned.hpp" +#include "Element.hpp" +#include "ElementQuad4.hpp" +#include "ElementHex8.hpp" +#include "Mesh.hpp" +#include "MeshTri3.hpp" +#include "MeshQuad4.hpp" +#include "MeshHex8.hpp" + +// ================================================================================================= + +PYBIND11_MODULE(GooseFEM, m) { + +// ------------------------------------------------------------------------------------------------- + +m.doc() = "Some simple finite element meshes and operations"; + +// ------------------------------------------------------------------------------------------------- + +init_Vector(m); + +// ------------------------------------------------------------------------------------------------- + +init_VectorPartitioned(m); + +// ------------------------------------------------------------------------------------------------- + +init_MatrixDiagonalPartitioned(m); + +// ------------------------------------------------------------------------------------------------- + +py::module mElement = m.def_submodule("Element", "Generic element routines"); + +init_Element(mElement); + +// ------------------------------------------------------------------------------------------------- + +py::module mElementQuad4 = mElement.def_submodule("Quad4", "Linear quadrilateral elements (2D)"); + +py::module mElementQuad4Gauss = mElementQuad4.def_submodule("Gauss", "Gauss quadrature"); + +py::module mElementQuad4Nodal = mElementQuad4.def_submodule("Nodal", "Nodal quadrature"); + +init_ElementQuad4(mElementQuad4); + +init_ElementQuad4Gauss(mElementQuad4Gauss); + +init_ElementQuad4Nodal(mElementQuad4Nodal); + +// ------------------------------------------------------------------------------------------------- + +py::module mElementHex8 = mElement.def_submodule("Hex8", "Linear hexahedron (brick) elements (3D)"); + +py::module mElementHex8Gauss = mElementHex8.def_submodule("Gauss", "Gauss quadrature"); + +py::module mElementHex8Nodal = mElementHex8.def_submodule("Nodal", "Nodal quadrature"); + +init_ElementHex8(mElementHex8); + +init_ElementHex8Gauss(mElementHex8Gauss); + +init_ElementHex8Nodal(mElementHex8Nodal); + +// ------------------------------------------------------------------------------------------------- + +py::module mMesh = m.def_submodule("Mesh", "Generic mesh routines"); + +init_Mesh(mMesh); + +// ------------------------------------------------------------------------------------------------- + +py::module mMeshTri3 = mMesh.def_submodule("Tri3", "Linear triangular elements (2D)"); + +init_MeshTri3(mMeshTri3); + +// ------------------------------------------------------------------------------------------------- + +py::module mMeshQuad4 = mMesh.def_submodule("Quad4", "Linear quadrilateral elements (2D)"); + +init_MeshQuad4(mMeshQuad4); + +// ------------------------------------------------------------------------------------------------- + +py::module mMeshHex8 = mMesh.def_submodule("Hex8", "Linear hexahedron (brick) elements (3D)"); + +init_MeshHex8(mMeshHex8); + +// ================================================================================================= + +} + diff --git a/setup.py b/setup.py index 0f31312..f251676 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/config.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] __version__ = '.'.join([world,major,minor]) ext_modules = [ Extension( 'GooseFEM', - ['include/GooseFEM/python.cpp'], + ['python/main.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, )