diff --git a/python/python_interface.cpp b/python/python_interface.cpp index e680b8d..205ee83 100644 --- a/python/python_interface.cpp +++ b/python/python_interface.cpp @@ -1,437 +1,437 @@ /* ================================================================================================= (c - GPLv3) T.W.J. de Geus (Tom) | tom@geus.me | www.geus.me | github.com/tdegeus/GooseFEM ================================================================================================= */ #include #include #include #include "../src/GooseFEM/GooseFEM.h" // alias for short-hand notation below namespace py = pybind11; PYBIND11_MODULE(GooseFEM, m) { // ================================================================================================= m.doc() = "Some simple finite element meshes and operations"; // define submodules "mXXX" py::module mMesh = m .def_submodule("Mesh" , "Generic mesh routines" ); py::module mMeshTri3 = mMesh.def_submodule("Tri3" , "Linear triangular elements (2D)" ); py::module mMeshQuad4 = mMesh.def_submodule("Quad4" , "Linear quadrilateral elements (2D)" ); py::module mMeshHex8 = mMesh.def_submodule("Hex8" , "Linear hexahedron (brick) elements (3D)"); // ======================================= GooseFEM/Mesh.h ======================================== mMesh.def("elem2node", &GooseFEM::Mesh::elem2node, "Elements connect to each node: [ number of elements , element numbers ]", py::arg("conn") ); mMesh.def("dofs", &GooseFEM::Mesh::dofs, "List with DOF-numbers (in sequential order)", py::arg("nnode"), py::arg("ndim") ); mMesh.def("renumber", py::overload_cast(&GooseFEM::Mesh::renumber), "Renumber DOF-list to use the lowest possible index", py::arg("dofs") ); mMesh.def("renumber", py::overload_cast(&GooseFEM::Mesh::renumber), "Renumber DOF-list to begin or end with 'idx'", py::arg("dofs"), py::arg("idx"), py::arg("location")="end" ); // ===================================== GooseFEM/MeshHex8.h ===================================== py::class_(mMeshHex8, "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("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 &a){ return ""; } ); // ------------------------------------------------------------------------------------------------- py::class_(mMeshHex8, "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("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("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("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("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("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("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 &a){ return ""; } ); // ===================================== GooseFEM/MeshQuad4.h ===================================== py::class_(mMeshQuad4, "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("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 &a){ return ""; } ); // ------------------------------------------------------------------------------------------------- py::class_(mMeshQuad4, "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, py::arg("nskip")=0 ) .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("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 &a){ return ""; } ); // ===================================== GooseFEM/MeshTri3.h ====================================== py::class_(mMeshTri3, "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("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 &a){ return ""; } ); // ------------------------------------------------------------------------------------------------- mMeshTri3.def("getOrientation",&GooseFEM::Mesh::Tri3::getOrientation, "Get the orientation of each element", py::arg("coor"), py::arg("conn") ); // ------------------------------------------------------------------------------------------------- mMeshTri3.def("retriangulate",&GooseFEM::Mesh::Tri3::retriangulate, "Re-triangulate existing mesh", py::arg("coor"), py::arg("conn"), py::arg("orientation")=-1 ); // ================================================================================================= } diff --git a/src/GooseFEM/MeshHex8.cpp b/src/GooseFEM/MeshHex8.cpp index 4e3200b..1891a7f 100644 --- a/src/GooseFEM/MeshHex8.cpp +++ b/src/GooseFEM/MeshHex8.cpp @@ -1,2223 +1,2279 @@ /* ================================================================================================= (c - GPLv3) T.W.J. de Geus (Tom) | tom@geus.me | www.geus.me | github.com/tdegeus/GooseFEM ================================================================================================= */ #ifndef GOOSEFEM_MESHHEX8_CPP #define GOOSEFEM_MESHHEX8_CPP // ------------------------------------------------------------------------------------------------- #include "MeshHex8.h" // ===================================== GooseFEM::Mesh::Hex8 ====================================== namespace GooseFEM { namespace Mesh { namespace Hex8 { // ===================================== CLASS - REGULAR MESH ====================================== // ------------------------------------------ constructor ------------------------------------------ inline Regular::Regular(size_t nelx, size_t nely, size_t nelz, double h): m_nelx(nelx), m_nely(nely), m_nelz(nelz), m_h(h) { assert( m_nelx >= 1 ); assert( m_nely >= 1 ); assert( m_nelz >= 1 ); m_nnode = (m_nelx+1) * (m_nely+1) * (m_nelz+1); m_nelem = m_nelx * m_nely * m_nelz ; } // -------------------------------------- number of elements --------------------------------------- inline size_t Regular::nelem() { return m_nelem; } // ---------------------------------------- number of nodes ---------------------------------------- inline size_t Regular::nnode() { return m_nnode; } // ---------------------------------- number of nodes per element ---------------------------------- inline size_t Regular::nne() { return m_nne; } // ------------------------------------- number of dimensions -------------------------------------- inline size_t Regular::ndim() { return m_ndim; } // --------------------------------- coordinates (nodal positions) --------------------------------- inline MatD Regular::coor() { MatD coor(m_nnode,m_ndim); ColD x = ColD::LinSpaced(m_nelx+1, 0.0, m_h*static_cast(m_nelx)); ColD y = ColD::LinSpaced(m_nely+1, 0.0, m_h*static_cast(m_nely)); ColD z = ColD::LinSpaced(m_nelz+1, 0.0, m_h*static_cast(m_nelz)); size_t inode = 0; for ( size_t iz = 0 ; iz < m_nelz+1 ; ++iz ) { for ( size_t iy = 0 ; iy < m_nely+1 ; ++iy ) { for ( size_t ix = 0 ; ix < m_nelx+1 ; ++ix ) { coor(inode,0) = x(ix); coor(inode,1) = y(iy); coor(inode,2) = z(iz); ++inode; } } } return coor; } // ---------------------------- connectivity (node-numbers per element) ---------------------------- inline MatS Regular::conn() { MatS conn(m_nelem,m_nne); size_t ielem = 0; for ( size_t iz = 0 ; iz < m_nelz ; ++iz ) { for ( size_t iy = 0 ; iy < m_nely ; ++iy ) { for ( size_t ix = 0 ; ix < m_nelx ; ++ix ) { conn(ielem,0) = (iz+0)*(m_nely+1)*(m_nelx+1) + (iy+0)*(m_nelx+1) + (ix+0); conn(ielem,1) = (iz+0)*(m_nely+1)*(m_nelx+1) + (iy+0)*(m_nelx+1) + (ix+1); conn(ielem,3) = (iz+0)*(m_nely+1)*(m_nelx+1) + (iy+1)*(m_nelx+1) + (ix+0); conn(ielem,2) = (iz+0)*(m_nely+1)*(m_nelx+1) + (iy+1)*(m_nelx+1) + (ix+1); conn(ielem,4) = (iz+1)*(m_nely+1)*(m_nelx+1) + (iy+0)*(m_nelx+1) + (ix+0); conn(ielem,5) = (iz+1)*(m_nely+1)*(m_nelx+1) + (iy+0)*(m_nelx+1) + (ix+1); conn(ielem,7) = (iz+1)*(m_nely+1)*(m_nelx+1) + (iy+1)*(m_nelx+1) + (ix+0); conn(ielem,6) = (iz+1)*(m_nely+1)*(m_nelx+1) + (iy+1)*(m_nelx+1) + (ix+1); ++ielem; } } } return conn; } // ------------------------------ node-numbers along the front plane ------------------------------ inline ColS Regular::nodesFront() { ColS nodes((m_nelx+1)*(m_nely+1)); for ( size_t iy = 0 ; iy < m_nely+1 ; ++iy ) for ( size_t ix = 0 ; ix < m_nelx+1 ; ++ix ) nodes(iy*(m_nelx+1)+ix) = iy*(m_nelx+1) + ix; return nodes; } // ------------------------------- node-numbers along the back plane -------------------------------- inline ColS Regular::nodesBack() { ColS nodes((m_nelx+1)*(m_nely+1)); for ( size_t iy = 0 ; iy < m_nely+1 ; ++iy ) for ( size_t ix = 0 ; ix < m_nelx+1 ; ++ix ) nodes(iy*(m_nelx+1)+ix) = iy*(m_nelx+1) + ix + m_nelz*(m_nely+1)*(m_nelx+1); return nodes; } // ------------------------------- node-numbers along the left plane ------------------------------- inline ColS Regular::nodesLeft() { ColS nodes((m_nely+1)*(m_nelz+1)); for ( size_t iz = 0 ; iz < m_nelz+1 ; ++iz ) for ( size_t iy = 0 ; iy < m_nely+1 ; ++iy ) nodes(iz*(m_nely+1)+iy) = iy*(m_nelx+1) + iz*(m_nelx+1)*(m_nely+1); return nodes; } // ------------------------------ node-numbers along the right plane ------------------------------- inline ColS Regular::nodesRight() { ColS nodes((m_nely+1)*(m_nelz+1)); for ( size_t iz = 0 ; iz < m_nelz+1 ; ++iz ) for ( size_t iy = 0 ; iy < m_nely+1 ; ++iy ) nodes(iz*(m_nely+1)+iy) = iy*(m_nelx+1) + iz*(m_nelx+1)*(m_nely+1) + m_nelx; return nodes; } // ------------------------------ node-numbers along the bottom plane ------------------------------- inline ColS Regular::nodesBottom() { ColS nodes((m_nelx+1)*(m_nelz+1)); for ( size_t iz = 0 ; iz < m_nelz+1 ; ++iz ) for ( size_t ix = 0 ; ix < m_nelx+1 ; ++ix ) nodes(iz*(m_nelx+1)+ix) = ix + iz*(m_nelx+1)*(m_nely+1); return nodes; } // ------------------------------- node-numbers along the top plane ------------------------------- inline ColS Regular::nodesTop() { ColS nodes((m_nelx+1)*(m_nelz+1)); for ( size_t iz = 0 ; iz < m_nelz+1 ; ++iz ) for ( size_t ix = 0 ; ix < m_nelx+1 ; ++ix ) nodes(iz*(m_nelx+1)+ix) = ix + m_nely*(m_nelx+1) + iz*(m_nelx+1)*(m_nely+1); return nodes; } // ------------------------------ node-numbers along the front face ------------------------------- inline ColS Regular::nodesFrontFace() { ColS nodes((m_nelx-1)*(m_nely-1)); for ( size_t iy = 1 ; iy < m_nely ; ++iy ) for ( size_t ix = 1 ; ix < m_nelx ; ++ix ) nodes((iy-1)*(m_nelx-1)+(ix-1)) = iy*(m_nelx+1) + ix; return nodes; } // -------------------------------- node-numbers along the back face -------------------------------- inline ColS Regular::nodesBackFace() { ColS nodes((m_nelx-1)*(m_nely-1)); for ( size_t iy = 1 ; iy < m_nely ; ++iy ) { for ( size_t ix = 1 ; ix < m_nelx ; ++ix ) { nodes((iy-1)*(m_nelx-1)+(ix-1)) = iy*(m_nelx+1) + ix + m_nelz*(m_nely+1)*(m_nelx+1); } } return nodes; } // ------------------------------- node-numbers along the left face -------------------------------- inline ColS Regular::nodesLeftFace() { ColS nodes((m_nely-1)*(m_nelz-1)); for ( size_t iz = 1 ; iz < m_nelz ; ++iz ) for ( size_t iy = 1 ; iy < m_nely ; ++iy ) nodes((iz-1)*(m_nely-1)+(iy-1)) = iy*(m_nelx+1) + iz*(m_nelx+1)*(m_nely+1); return nodes; } // ------------------------------- node-numbers along the right face ------------------------------- inline ColS Regular::nodesRightFace() { ColS nodes((m_nely-1)*(m_nelz-1)); for ( size_t iz = 1 ; iz < m_nelz ; ++iz ) for ( size_t iy = 1 ; iy < m_nely ; ++iy ) nodes((iz-1)*(m_nely-1)+(iy-1)) = iy*(m_nelx+1) + iz*(m_nelx+1)*(m_nely+1) + m_nelx; return nodes; } // ------------------------------- node-numbers along the bottom face ------------------------------- inline ColS Regular::nodesBottomFace() { ColS nodes((m_nelx-1)*(m_nelz-1)); for ( size_t iz = 1 ; iz < m_nelz ; ++iz ) for ( size_t ix = 1 ; ix < m_nelx ; ++ix ) nodes((iz-1)*(m_nelx-1)+(ix-1)) = ix + iz*(m_nelx+1)*(m_nely+1); return nodes; } // ------------------------------- node-numbers along the top face -------------------------------- inline ColS Regular::nodesTopFace() { ColS nodes((m_nelx-1)*(m_nelz-1)); for ( size_t iz = 1 ; iz < m_nelz ; ++iz ) for ( size_t ix = 1 ; ix < m_nelx ; ++ix ) nodes((iz-1)*(m_nelx-1)+(ix-1)) = ix + m_nely*(m_nelx+1) + iz*(m_nelx+1)*(m_nely+1); return nodes; } // --------------------------- node-numbers along the front-bottom edge ---------------------------- inline ColS Regular::nodesFrontBottomEdge() { ColS nodes(m_nelx+1); for ( size_t ix = 0 ; ix < m_nelx+1 ; ++ix ) nodes(ix) = ix; return nodes; } // ---------------------------- node-numbers along the front-top edge ---------------------------- inline ColS Regular::nodesFrontTopEdge() { ColS nodes(m_nelx+1); for ( size_t ix = 0 ; ix < m_nelx+1 ; ++ix ) nodes(ix) = m_nely*(m_nelx+1) + ix; return nodes; } // ---------------------------- node-numbers along the front-left edge ---------------------------- inline ColS Regular::nodesFrontLeftEdge() { ColS nodes(m_nely+1); for ( size_t iy = 0 ; iy < m_nely+1 ; ++iy ) nodes(iy) = iy*(m_nelx+1); return nodes; } // --------------------------- node-numbers along the front-right edge ---------------------------- inline ColS Regular::nodesFrontRightEdge() { ColS nodes(m_nely+1); for ( size_t iy = 0 ; iy < m_nely+1 ; ++iy ) nodes(iy) = iy*(m_nelx+1) + m_nelx; return nodes; } // ----------------------------- node-numbers along the back-bottom edge ----------------------------- inline ColS Regular::nodesBackBottomEdge() { ColS nodes(m_nelx+1); for ( size_t ix = 0 ; ix < m_nelx+1 ; ++ix ) nodes(ix) = ix + m_nelz*(m_nely+1)*(m_nelx+1); return nodes; } // ----------------------------- node-numbers along the back-top edge ------------------------------ inline ColS Regular::nodesBackTopEdge() { ColS nodes(m_nelx+1); for ( size_t ix = 0 ; ix < m_nelx+1 ; ++ix ) nodes(ix) = m_nely*(m_nelx+1) + ix + m_nelz*(m_nely+1)*(m_nelx+1); return nodes; } // ----------------------------- node-numbers along the back-left edge ------------------------------ inline ColS Regular::nodesBackLeftEdge() { ColS nodes(m_nely+1); for ( size_t iy = 0 ; iy < m_nely+1 ; ++iy ) nodes(iy) = iy*(m_nelx+1) + m_nelz*(m_nelx+1)*(m_nely+1); return nodes; } // ----------------------------- node-numbers along the back-right edge ----------------------------- inline ColS Regular::nodesBackRightEdge() { ColS nodes(m_nely+1); for ( size_t iy = 0 ; iy < m_nely+1 ; ++iy ) nodes(iy) = iy*(m_nelx+1) + m_nelz*(m_nelx+1)*(m_nely+1) + m_nelx; return nodes; } // ---------------------------- node-numbers along the bottom-left edge ----------------------------- inline ColS Regular::nodesBottomLeftEdge() { ColS nodes(m_nelz+1); for ( size_t iz = 0 ; iz < m_nelz+1 ; ++iz ) nodes(iz) = iz*(m_nelx+1)*(m_nely+1); return nodes; } // ---------------------------- node-numbers along the bottom-right edge ---------------------------- inline ColS Regular::nodesBottomRightEdge() { ColS nodes(m_nelz+1); for ( size_t iz = 0 ; iz < m_nelz+1 ; ++iz ) nodes(iz) = iz*(m_nelx+1)*(m_nely+1) + m_nelx; return nodes; } // -------------------------- node-numbers along the node top-left edge --------------------------- inline ColS Regular::nodesTopLeftEdge() { ColS nodes(m_nelz+1); for ( size_t iz = 0 ; iz < m_nelz+1 ; ++iz ) nodes(iz) = m_nely*(m_nelx+1) + iz*(m_nelx+1)*(m_nely+1); return nodes; } // ---------------------------- node-numbers along the top-right edge ----------------------------- inline ColS Regular::nodesTopRightEdge() { ColS nodes(m_nelz+1); for ( size_t iz = 0 ; iz < m_nelz+1 ; ++iz ) nodes(iz) = m_nely*(m_nelx+1) + iz*(m_nelx+1)*(m_nely+1) + m_nelx; return nodes; } // -------------------------------------------- aliases -------------------------------------------- inline ColS Regular::nodesBottomFrontEdge() { return nodesFrontBottomEdge(); } inline ColS Regular::nodesBottomBackEdge() { return nodesBackBottomEdge(); } inline ColS Regular::nodesTopFrontEdge() { return nodesFrontTopEdge(); } inline ColS Regular::nodesTopBackEdge() { return nodesBackTopEdge(); } inline ColS Regular::nodesLeftBottomEdge() { return nodesBottomLeftEdge(); } inline ColS Regular::nodesLeftFrontEdge() { return nodesFrontLeftEdge(); } inline ColS Regular::nodesLeftBackEdge() { return nodesBackLeftEdge(); } inline ColS Regular::nodesLeftTopEdge() { return nodesTopLeftEdge(); } inline ColS Regular::nodesRightBottomEdge() { return nodesBottomRightEdge(); } inline ColS Regular::nodesRightTopEdge() { return nodesTopRightEdge(); } inline ColS Regular::nodesRightFrontEdge() { return nodesFrontRightEdge(); } inline ColS Regular::nodesRightBackEdge() { return nodesBackRightEdge(); } // -------------------------- node-number of the front-bottom-left corner -------------------------- inline size_t Regular::nodesFrontBottomLeftCorner() { return 0; } // -------------------------- node-number of the front-bottom-right corner -------------------------- inline size_t Regular::nodesFrontBottomRightCorner() { return m_nelx; } // -------------------------- node-number of the front-top-left corner --------------------------- inline size_t Regular::nodesFrontTopLeftCorner() { return m_nely*(m_nelx+1); } // -------------------------- node-number of the front-top-right corner -------------------------- inline size_t Regular::nodesFrontTopRightCorner() { return m_nely*(m_nelx+1) + m_nelx; } // -------------------------- node-number of the back-bottom-left corner -------------------------- inline size_t Regular::nodesBackBottomLeftCorner() { return m_nelz*(m_nely+1)*(m_nelx+1); } // -------------------------- node-number of the back-bottom-right corner -------------------------- inline size_t Regular::nodesBackBottomRightCorner() { return m_nelx + m_nelz*(m_nely+1)*(m_nelx+1); } // -------------------------- node-number of the back-top-left corner --------------------------- inline size_t Regular::nodesBackTopLeftCorner() { return m_nely*(m_nelx+1) + m_nelz*(m_nely+1)*(m_nelx+1); } // -------------------------- node-number of the back-top-right corner -------------------------- inline size_t Regular::nodesBackTopRightCorner() { return m_nely*(m_nelx+1) + m_nelx + m_nelz*(m_nely+1)*(m_nelx+1); } // -------------------------------------------- aliases -------------------------------------------- inline size_t Regular::nodesFrontLeftBottomCorner() { return nodesFrontBottomLeftCorner(); } inline size_t Regular::nodesBottomFrontLeftCorner() { return nodesFrontBottomLeftCorner(); } inline size_t Regular::nodesBottomLeftFrontCorner() { return nodesFrontBottomLeftCorner(); } inline size_t Regular::nodesLeftFrontBottomCorner() { return nodesFrontBottomLeftCorner(); } inline size_t Regular::nodesLeftBottomFrontCorner() { return nodesFrontBottomLeftCorner(); } inline size_t Regular::nodesFrontRightBottomCorner() { return nodesFrontBottomRightCorner(); } inline size_t Regular::nodesBottomFrontRightCorner() { return nodesFrontBottomRightCorner(); } inline size_t Regular::nodesBottomRightFrontCorner() { return nodesFrontBottomRightCorner(); } inline size_t Regular::nodesRightFrontBottomCorner() { return nodesFrontBottomRightCorner(); } inline size_t Regular::nodesRightBottomFrontCorner() { return nodesFrontBottomRightCorner(); } inline size_t Regular::nodesFrontLeftTopCorner() { return nodesFrontTopLeftCorner(); } inline size_t Regular::nodesTopFrontLeftCorner() { return nodesFrontTopLeftCorner(); } inline size_t Regular::nodesTopLeftFrontCorner() { return nodesFrontTopLeftCorner(); } inline size_t Regular::nodesLeftFrontTopCorner() { return nodesFrontTopLeftCorner(); } inline size_t Regular::nodesLeftTopFrontCorner() { return nodesFrontTopLeftCorner(); } inline size_t Regular::nodesFrontRightTopCorner() { return nodesFrontTopRightCorner(); } inline size_t Regular::nodesTopFrontRightCorner() { return nodesFrontTopRightCorner(); } inline size_t Regular::nodesTopRightFrontCorner() { return nodesFrontTopRightCorner(); } inline size_t Regular::nodesRightFrontTopCorner() { return nodesFrontTopRightCorner(); } inline size_t Regular::nodesRightTopFrontCorner() { return nodesFrontTopRightCorner(); } inline size_t Regular::nodesBackLeftBottomCorner() { return nodesBackBottomLeftCorner(); } inline size_t Regular::nodesBottomBackLeftCorner() { return nodesBackBottomLeftCorner(); } inline size_t Regular::nodesBottomLeftBackCorner() { return nodesBackBottomLeftCorner(); } inline size_t Regular::nodesLeftBackBottomCorner() { return nodesBackBottomLeftCorner(); } inline size_t Regular::nodesLeftBottomBackCorner() { return nodesBackBottomLeftCorner(); } inline size_t Regular::nodesBackRightBottomCorner() { return nodesBackBottomRightCorner(); } inline size_t Regular::nodesBottomBackRightCorner() { return nodesBackBottomRightCorner(); } inline size_t Regular::nodesBottomRightBackCorner() { return nodesBackBottomRightCorner(); } inline size_t Regular::nodesRightBackBottomCorner() { return nodesBackBottomRightCorner(); } inline size_t Regular::nodesRightBottomBackCorner() { return nodesBackBottomRightCorner(); } inline size_t Regular::nodesBackLeftTopCorner() { return nodesBackTopLeftCorner(); } inline size_t Regular::nodesTopBackLeftCorner() { return nodesBackTopLeftCorner(); } inline size_t Regular::nodesTopLeftBackCorner() { return nodesBackTopLeftCorner(); } inline size_t Regular::nodesLeftBackTopCorner() { return nodesBackTopLeftCorner(); } inline size_t Regular::nodesLeftTopBackCorner() { return nodesBackTopLeftCorner(); } inline size_t Regular::nodesBackRightTopCorner() { return nodesBackTopRightCorner(); } inline size_t Regular::nodesTopBackRightCorner() { return nodesBackTopRightCorner(); } inline size_t Regular::nodesTopRightBackCorner() { return nodesBackTopRightCorner(); } inline size_t Regular::nodesRightBackTopCorner() { return nodesBackTopRightCorner(); } inline size_t Regular::nodesRightTopBackCorner() { return nodesBackTopRightCorner(); } // ------------------------------ node-numbers of periodic node-pairs ------------------------------ inline MatS Regular::nodesPeriodic() { // faces ColS fro = nodesFrontFace(); ColS bck = nodesBackFace(); ColS lft = nodesLeftFace(); ColS rgt = nodesRightFace(); ColS bot = nodesBottomFace(); ColS top = nodesTopFace(); // edges ColS froBot = nodesFrontBottomEdge(); ColS froTop = nodesFrontTopEdge(); ColS froLft = nodesFrontLeftEdge(); ColS froRgt = nodesFrontRightEdge(); ColS bckBot = nodesBackBottomEdge(); ColS bckTop = nodesBackTopEdge(); ColS bckLft = nodesBackLeftEdge(); ColS bckRgt = nodesBackRightEdge(); ColS botLft = nodesBottomLeftEdge(); ColS botRgt = nodesBottomRightEdge(); ColS topLft = nodesTopLeftEdge(); ColS topRgt = nodesTopRightEdge(); // allocate nodal ties // - number of tying per category size_t tface = fro.size() + lft.size() + bot.size(); size_t tedge = 3*(froBot.size()-2) + 3*(froLft.size()-2) + 3*(botLft.size()-2); size_t tnode = 7; // - allocate MatS nodes(tface+tedge+tnode, 2); // counter size_t i = 0; // tie all corners to one corner nodes(i,0) = nodesFrontBottomLeftCorner(); nodes(i,1) = nodesFrontBottomRightCorner(); ++i; nodes(i,0) = nodesFrontBottomLeftCorner(); nodes(i,1) = nodesBackBottomRightCorner(); ++i; nodes(i,0) = nodesFrontBottomLeftCorner(); nodes(i,1) = nodesBackBottomLeftCorner(); ++i; nodes(i,0) = nodesFrontBottomLeftCorner(); nodes(i,1) = nodesFrontTopLeftCorner(); ++i; nodes(i,0) = nodesFrontBottomLeftCorner(); nodes(i,1) = nodesFrontTopRightCorner(); ++i; nodes(i,0) = nodesFrontBottomLeftCorner(); nodes(i,1) = nodesBackTopRightCorner(); ++i; nodes(i,0) = nodesFrontBottomLeftCorner(); nodes(i,1) = nodesBackTopLeftCorner(); ++i; // tie all corresponding edges to each other (exclude corners) for ( auto j=1; j(nodePer.rows()); // eliminate 'dependent' DOFs; renumber "out" to be sequential for the remaining DOFs for ( size_t i = 0 ; i < nper ; ++i ) for ( size_t j = 0 ; j < m_ndim ; ++j ) out(nodePer(i,1),j) = out(nodePer(i,0),j); // renumber "out" to be sequential return GooseFEM::Mesh::renumber(out); } // ==================================== CLASS - FINELAYER MESH ===================================== // ------------------------------------------ constructor ------------------------------------------ inline FineLayer::FineLayer(size_t nelx, size_t nely, size_t nelz, double h, size_t nfine): m_h(h), m_nelx(nelx), m_nelz(nelz) { // basic assumptions assert( nelx >= 1 ); assert( nely >= 1 ); assert( nelz >= 1 ); // store basic info m_Lx = m_h * static_cast(nelx); m_Lz = m_h * static_cast(nelz); // compute element size in y-direction (use symmetry, compute upper half) // ---------------------------------------------------------------------- // temporary variables size_t nmin, ntot; ColS nhx(nely), nhy(nely), nhz(nely); ColI refine(nely); // minimum height in y-direction (half of the height because of symmetry) if ( nely % 2 == 0 ) nmin = nely /2; else nmin = (nely +1)/2; // minimum number of fine layers in y-direction (minimum 1, middle layer part of this half) if ( nfine % 2 == 0 ) nfine = nfine /2 + 1; else nfine = (nfine+1)/2; if ( nfine < 1 ) nfine = 1; if ( nfine > nmin ) nfine = nmin; // initialize to state with only fine elements nhx .setOnes(); nhy .setOnes(); nhz .setOnes(); refine.setConstant(-1); // loop over element layers in y-direction, try to coarsen using these rules: // (1) element size in y-direction <= distance to origin in y-direction // (2) element size in x-(z-)direction should fit the total number of elements in x-(z-)direction // (3) a certain number of layers have the minimum size "1" (are fine) for ( size_t iy = nfine ; ; ) { // initialize current size in y-direction if ( iy == nfine ) ntot = nfine; // check to stop if ( iy >= nely or ntot >= nmin ) { nely = iy; break; } // rules (1,2) satisfied: coarsen in x-direction (and z-direction) if ( 3*nhy(iy) <= ntot and nelx%(3*nhx(iy)) == 0 ) { // - process refinement in x-direction refine (iy ) = 0; nhy (iy ) *= 2; nhy.segment(iy+1,nely-iy-1) *= 3; nhx.segment(iy ,nely-iy ) *= 3; // - rule (2) satisfied: coarsen next element layer in z-direction if ( iy+1 < nely and ntot+nhy(iy) < nmin ) { if ( nelz%(3*nhz(iy+1)) == 0 ) { // - update the number of elements in y-direction ntot += nhy(iy); // - proceed to next element layer in y-direction ++iy; // - process refinement in z-direction refine (iy ) = 2; nhy (iy ) = nhy(iy-1); nhz.segment(iy,nely-iy) *= 3; } } } // rules (1,2) satisfied: coarse in z-direction else if ( 3*nhy(iy) <= ntot and nelz%(3*nhz(iy)) == 0 ) { // - process refinement in z-direction refine (iy ) = 2; nhy (iy ) *= 2; nhy.segment(iy+1,nely-iy-1) *= 3; nhz.segment(iy ,nely-iy ) *= 3; } // update the number of elements in y-direction ntot += nhy(iy); // proceed to next element layer in y-direction ++iy; // check to stop if ( iy >= nely or ntot >= nmin ) { nely = iy; break; } } // symmetrize, compute full information // ------------------------------------ // allocate mesh constructor parameters m_nhx .conservativeResize(nely*2-1); m_nhy .conservativeResize(nely*2-1); m_nhz .conservativeResize(nely*2-1); m_refine .conservativeResize(nely*2-1); m_nelx .conservativeResize(nely*2-1); m_nelz .conservativeResize(nely*2-1); m_nnd .conservativeResize(nely*2 ); m_startElem.conservativeResize(nely*2-1); m_startNode.conservativeResize(nely*2 ); // fill // - lower half for ( size_t iy = 0 ; iy < nely ; ++iy ) { m_nhx (iy) = nhx (nely-iy-1); m_nhy (iy) = nhy (nely-iy-1); m_nhz (iy) = nhz (nely-iy-1); m_refine(iy) = refine(nely-iy-1); } // - upper half for ( size_t iy = 0 ; iy < nely-1 ; ++iy ) { m_nhx (iy+nely) = nhx (iy+1); m_nhy (iy+nely) = nhy (iy+1); m_nhz (iy+nely) = nhz (iy+1); m_refine(iy+nely) = refine(iy+1); } // update size nely = m_nhx.size(); // compute the number of elements per element layer in y-direction for ( size_t iy = 0 ; iy < nely ; ++iy ) { m_nelx(iy) = nelx / m_nhx(iy); m_nelz(iy) = nelz / m_nhz(iy); } // compute the number of nodes per node layer in y-direction // - bottom half for ( size_t iy = 0 ; iy < (nely+1)/2 ; ++iy ) m_nnd(iy) = (m_nelx(iy)+1) * (m_nelz(iy)+1); // - top half for ( size_t iy = (nely-1)/2 ; iy < nely ; ++iy ) m_nnd(iy+1) = (m_nelx(iy)+1) * (m_nelz(iy)+1); // compute mesh dimensions // ----------------------- // initialize m_nnode = 0; m_nelem = 0; m_startNode(0) = 0; // loop over element layers (bottom -> middle, elements become finer) for ( size_t i = 0 ; i < (nely-1)/2 ; ++i ) { // - store the first element of the layer m_startElem(i) = m_nelem; // - add the nodes of this layer if ( m_refine(i) == 0 ) { m_nnode += (3*m_nelx(i)+1) * ( m_nelz(i)+1); } else if ( m_refine(i) == 2 ) { m_nnode += ( m_nelx(i)+1) * (3*m_nelz(i)+1); } else { m_nnode += ( m_nelx(i)+1) * ( m_nelz(i)+1); } // - add the elements of this layer if ( m_refine(i) == 0 ) { m_nelem += (4*m_nelx(i) ) * ( m_nelz(i) ); } else if ( m_refine(i) == 2 ) { m_nelem += ( m_nelx(i) ) * (4*m_nelz(i) ); } else { m_nelem += ( m_nelx(i) ) * ( m_nelz(i) ); } // - store the starting node of the next layer m_startNode(i+1) = m_nnode; } // loop over element layers (middle -> top, elements become coarser) for ( size_t i = (nely-1)/2 ; i < nely ; ++i ) { // - store the first element of the layer m_startElem(i) = m_nelem; // - add the nodes of this layer if ( m_refine(i) == 0 ) { m_nnode += (5*m_nelx(i)+1) * ( m_nelz(i)+1); } else if ( m_refine(i) == 2 ) { m_nnode += ( m_nelx(i)+1) * (5*m_nelz(i)+1); } else { m_nnode += ( m_nelx(i)+1) * ( m_nelz(i)+1); } // - add the elements of this layer if ( m_refine(i) == 0 ) { m_nelem += (4*m_nelx(i) ) * ( m_nelz(i) ); } else if ( m_refine(i) == 2 ) { m_nelem += ( m_nelx(i) ) * (4*m_nelz(i) ); } else { m_nelem += ( m_nelx(i) ) * ( m_nelz(i) ); } // - store the starting node of the next layer m_startNode(i+1) = m_nnode; } // - add the top row of nodes m_nnode += (m_nelx(nely-1)+1) * (m_nelz(nely-1)+1); } // -------------------------------------- number of elements --------------------------------------- inline size_t FineLayer::nelem() { return m_nelem; } // ---------------------------------------- number of nodes ---------------------------------------- inline size_t FineLayer::nnode() { return m_nnode; } // ---------------------------------- number of nodes per element ---------------------------------- inline size_t FineLayer::nne() { return m_nne; } // ------------------------------------- number of dimensions -------------------------------------- inline size_t FineLayer::ndim() { return m_ndim; } // ---------------------------- actual number of nodes in one direction ---------------------------- inline size_t FineLayer::shape(size_t i) { assert( i >= 0 and i <= 2 ); if ( i == 0 ) return m_nelx.maxCoeff(); else if ( i == 2 ) return m_nelz.maxCoeff(); else return m_nhy .sum(); } // --------------------------------- coordinates (nodal positions) --------------------------------- inline MatD FineLayer::coor() { // allocate output MatD out(m_nnode, m_ndim); // current node, number of element layers size_t inode = 0; size_t nely = static_cast(m_nhy.size()); // y-position of each main node layer (i.e. excluding node layers for refinement/coarsening) // - allocate ColD y(nely+1); // - initialize y(0) = 0.0; // - compute for ( size_t iy = 1 ; iy < nely+1 ; ++iy ) y(iy) = y(iy-1) + m_nhy(iy-1) * m_h; // loop over element layers (bottom -> middle) : add bottom layer (+ refinement layer) of nodes // -------------------------------------------------------------------------------------------- for ( size_t iy = 0 ; ; ++iy ) { // get positions along the x- and z-axis ColD x = ColD::LinSpaced(m_nelx(iy)+1, 0.0, m_Lx); ColD z = ColD::LinSpaced(m_nelz(iy)+1, 0.0, m_Lz); // add nodes of the bottom layer of this element for ( size_t iz = 0 ; iz < m_nelz(iy)+1 ; ++iz ) { for ( size_t ix = 0 ; ix < m_nelx(iy)+1 ; ++ix ) { out(inode,0) = x(ix); out(inode,1) = y(iy); out(inode,2) = z(iz); ++inode; } } // stop at middle layer if ( iy == (nely-1)/2 ) break; // add extra nodes of the intermediate layer, for refinement in x-direction if ( m_refine(iy) == 0 ) { // - get position offset in x- and y-direction double dx = m_h * static_cast(m_nhx(iy)/3); double dy = m_h * static_cast(m_nhy(iy)/2); // - add nodes of the intermediate layer for ( size_t iz = 0 ; iz < m_nelz(iy)+1 ; ++iz ) { for ( size_t ix = 0 ; ix < m_nelx(iy) ; ++ix ) { for ( size_t j = 0 ; j < 2 ; ++j ) { out(inode,0) = x(ix) + dx * static_cast(j+1); out(inode,1) = y(iy) + dy; out(inode,2) = z(iz); ++inode; } } } } // add extra nodes of the intermediate layer, for refinement in z-direction else if ( m_refine(iy) == 2 ) { // - get position offset in y- and z-direction double dz = m_h * static_cast(m_nhz(iy)/3); double dy = m_h * static_cast(m_nhy(iy)/2); // - add nodes of the intermediate layer for ( size_t iz = 0 ; iz < m_nelz(iy) ; ++iz ) { for ( size_t j = 0 ; j < 2 ; ++j ) { for ( size_t ix = 0 ; ix < m_nelx(iy)+1 ; ++ix ) { out(inode,0) = x(ix); out(inode,1) = y(iy) + dy; out(inode,2) = z(iz) + dz * static_cast(j+1); ++inode; } } } } } // loop over element layers (middle -> top) : add (refinement layer +) top layer of nodes // -------------------------------------------------------------------------------------- for ( size_t iy = (nely-1)/2 ; iy < nely ; ++iy ) { // get positions along the x- and z-axis ColD x = ColD::LinSpaced(m_nelx(iy)+1, 0.0, m_Lx); ColD z = ColD::LinSpaced(m_nelz(iy)+1, 0.0, m_Lz); // add extra nodes of the intermediate layer, for refinement in x-direction if ( m_refine(iy) == 0 ) { // - get position offset in x- and y-direction double dx = m_h * static_cast(m_nhx(iy)/3); double dy = m_h * static_cast(m_nhy(iy)/2); // - add nodes of the intermediate layer for ( size_t iz = 0 ; iz < m_nelz(iy)+1 ; ++iz ) { for ( size_t ix = 0 ; ix < m_nelx(iy) ; ++ix ) { for ( size_t j = 0 ; j < 2 ; ++j ) { out(inode,0) = x(ix) + dx * static_cast(j+1); out(inode,1) = y(iy) + dy; out(inode,2) = z(iz); ++inode; } } } } // add extra nodes of the intermediate layer, for refinement in z-direction else if ( m_refine(iy) == 2 ) { // - get position offset in y- and z-direction double dz = m_h * static_cast(m_nhz(iy)/3); double dy = m_h * static_cast(m_nhy(iy)/2); // - add nodes of the intermediate layer for ( size_t iz = 0 ; iz < m_nelz(iy) ; ++iz ) { for ( size_t j = 0 ; j < 2 ; ++j ) { for ( size_t ix = 0 ; ix < m_nelx(iy)+1 ; ++ix ) { out(inode,0) = x(ix); out(inode,1) = y(iy) + dy; out(inode,2) = z(iz) + dz * static_cast(j+1); ++inode; } } } } // add nodes of the top layer of this element for ( size_t iz = 0 ; iz < m_nelz(iy)+1 ; ++iz ) { for ( size_t ix = 0 ; ix < m_nelx(iy)+1 ; ++ix ) { out(inode,0) = x(ix ); out(inode,1) = y(iy+1); out(inode,2) = z(iz ); ++inode; } } } return out; } // ---------------------------- connectivity (node-numbers per element) ---------------------------- inline MatS FineLayer::conn() { // allocate output MatS out(m_nelem, m_nne); // current element, number of element layers, starting nodes of each node layer size_t ielem = 0; size_t nely = static_cast(m_nhy.size()); size_t bot,mid,top; // loop over all element layers for ( size_t iy = 0 ; iy < nely ; ++iy ) { // - get: starting nodes of bottom(, middle) and top layer bot = m_startNode(iy ); mid = m_startNode(iy ) + m_nnd(iy); top = m_startNode(iy+1); // - define connectivity: no coarsening/refinement if ( m_refine(iy) == -1 ) { for ( size_t iz = 0 ; iz < m_nelz(iy) ; ++iz ) { for ( size_t ix = 0 ; ix < m_nelx(iy) ; ++ix ) { out(ielem,0) = bot + (ix ) + (iz ) * (m_nelx(iy)+1); out(ielem,1) = bot + (ix+1) + (iz ) * (m_nelx(iy)+1); out(ielem,2) = top + (ix+1) + (iz ) * (m_nelx(iy)+1); out(ielem,3) = top + (ix ) + (iz ) * (m_nelx(iy)+1); out(ielem,4) = bot + (ix ) + (iz+1) * (m_nelx(iy)+1); out(ielem,5) = bot + (ix+1) + (iz+1) * (m_nelx(iy)+1); out(ielem,6) = top + (ix+1) + (iz+1) * (m_nelx(iy)+1); out(ielem,7) = top + (ix ) + (iz+1) * (m_nelx(iy)+1); ielem++; } } } // - define connectivity: refinement along the x-direction (below the middle layer) else if ( m_refine(iy) == 0 and iy <= (nely-1)/2 ) { for ( size_t iz = 0 ; iz < m_nelz(iy) ; ++iz ) { for ( size_t ix = 0 ; ix < m_nelx(iy) ; ++ix ) { // -- bottom element out(ielem,0) = bot + ( ix ) + (iz ) * ( m_nelx(iy)+1); out(ielem,1) = bot + ( ix+1) + (iz ) * ( m_nelx(iy)+1); out(ielem,2) = mid + (2*ix+1) + (iz ) * (2*m_nelx(iy) ); out(ielem,3) = mid + (2*ix ) + (iz ) * (2*m_nelx(iy) ); out(ielem,4) = bot + ( ix ) + (iz+1) * ( m_nelx(iy)+1); out(ielem,5) = bot + ( ix+1) + (iz+1) * ( m_nelx(iy)+1); out(ielem,6) = mid + (2*ix+1) + (iz+1) * (2*m_nelx(iy) ); out(ielem,7) = mid + (2*ix ) + (iz+1) * (2*m_nelx(iy) ); ielem++; // -- top-right element out(ielem,0) = bot + ( ix+1) + (iz ) * ( m_nelx(iy)+1); out(ielem,1) = top + (3*ix+3) + (iz ) * (3*m_nelx(iy)+1); out(ielem,2) = top + (3*ix+2) + (iz ) * (3*m_nelx(iy)+1); out(ielem,3) = mid + (2*ix+1) + (iz ) * (2*m_nelx(iy) ); out(ielem,4) = bot + ( ix+1) + (iz+1) * ( m_nelx(iy)+1); out(ielem,5) = top + (3*ix+3) + (iz+1) * (3*m_nelx(iy)+1); out(ielem,6) = top + (3*ix+2) + (iz+1) * (3*m_nelx(iy)+1); out(ielem,7) = mid + (2*ix+1) + (iz+1) * (2*m_nelx(iy) ); ielem++; // -- top-center element out(ielem,0) = mid + (2*ix ) + (iz ) * (2*m_nelx(iy) ); out(ielem,1) = mid + (2*ix+1) + (iz ) * (2*m_nelx(iy) ); out(ielem,2) = top + (3*ix+2) + (iz ) * (3*m_nelx(iy)+1); out(ielem,3) = top + (3*ix+1) + (iz ) * (3*m_nelx(iy)+1); out(ielem,4) = mid + (2*ix ) + (iz+1) * (2*m_nelx(iy) ); out(ielem,5) = mid + (2*ix+1) + (iz+1) * (2*m_nelx(iy) ); out(ielem,6) = top + (3*ix+2) + (iz+1) * (3*m_nelx(iy)+1); out(ielem,7) = top + (3*ix+1) + (iz+1) * (3*m_nelx(iy)+1); ielem++; // -- top-left element out(ielem,0) = bot + ( ix ) + (iz ) * ( m_nelx(iy)+1); out(ielem,1) = mid + (2*ix ) + (iz ) * (2*m_nelx(iy) ); out(ielem,2) = top + (3*ix+1) + (iz ) * (3*m_nelx(iy)+1); out(ielem,3) = top + (3*ix ) + (iz ) * (3*m_nelx(iy)+1); out(ielem,4) = bot + ( ix ) + (iz+1) * ( m_nelx(iy)+1); out(ielem,5) = mid + (2*ix ) + (iz+1) * (2*m_nelx(iy) ); out(ielem,6) = top + (3*ix+1) + (iz+1) * (3*m_nelx(iy)+1); out(ielem,7) = top + (3*ix ) + (iz+1) * (3*m_nelx(iy)+1); ielem++; } } } // - define connectivity: coarsening along the x-direction (above the middle layer) else if ( m_refine(iy) == 0 and iy > (nely-1)/2 ) { for ( size_t iz = 0 ; iz < m_nelz(iy) ; ++iz ) { for ( size_t ix = 0 ; ix < m_nelx(iy) ; ++ix ) { // -- lower-left element out(ielem,0) = bot + (3*ix ) + (iz ) * (3*m_nelx(iy)+1); out(ielem,1) = bot + (3*ix+1) + (iz ) * (3*m_nelx(iy)+1); out(ielem,2) = mid + (2*ix ) + (iz ) * (2*m_nelx(iy) ); out(ielem,3) = top + ( ix ) + (iz ) * ( m_nelx(iy)+1); out(ielem,4) = bot + (3*ix ) + (iz+1) * (3*m_nelx(iy)+1); out(ielem,5) = bot + (3*ix+1) + (iz+1) * (3*m_nelx(iy)+1); out(ielem,6) = mid + (2*ix ) + (iz+1) * (2*m_nelx(iy) ); out(ielem,7) = top + ( ix ) + (iz+1) * ( m_nelx(iy)+1); ielem++; // -- lower-center element out(ielem,0) = bot + (3*ix+1) + (iz ) * (3*m_nelx(iy)+1); out(ielem,1) = bot + (3*ix+2) + (iz ) * (3*m_nelx(iy)+1); out(ielem,2) = mid + (2*ix+1) + (iz ) * (2*m_nelx(iy) ); out(ielem,3) = mid + (2*ix ) + (iz ) * (2*m_nelx(iy) ); out(ielem,4) = bot + (3*ix+1) + (iz+1) * (3*m_nelx(iy)+1); out(ielem,5) = bot + (3*ix+2) + (iz+1) * (3*m_nelx(iy)+1); out(ielem,6) = mid + (2*ix+1) + (iz+1) * (2*m_nelx(iy) ); out(ielem,7) = mid + (2*ix ) + (iz+1) * (2*m_nelx(iy) ); ielem++; // -- lower-right element out(ielem,0) = bot + (3*ix+2) + (iz ) * (3*m_nelx(iy)+1); out(ielem,1) = bot + (3*ix+3) + (iz ) * (3*m_nelx(iy)+1); out(ielem,2) = top + ( ix+1) + (iz ) * ( m_nelx(iy)+1); out(ielem,3) = mid + (2*ix+1) + (iz ) * (2*m_nelx(iy) ); out(ielem,4) = bot + (3*ix+2) + (iz+1) * (3*m_nelx(iy)+1); out(ielem,5) = bot + (3*ix+3) + (iz+1) * (3*m_nelx(iy)+1); out(ielem,6) = top + ( ix+1) + (iz+1) * ( m_nelx(iy)+1); out(ielem,7) = mid + (2*ix+1) + (iz+1) * (2*m_nelx(iy) ); ielem++; // -- upper element out(ielem,0) = mid + (2*ix ) + (iz ) * (2*m_nelx(iy) ); out(ielem,1) = mid + (2*ix+1) + (iz ) * (2*m_nelx(iy) ); out(ielem,2) = top + ( ix+1) + (iz ) * ( m_nelx(iy)+1); out(ielem,3) = top + ( ix ) + (iz ) * ( m_nelx(iy)+1); out(ielem,4) = mid + (2*ix ) + (iz+1) * (2*m_nelx(iy) ); out(ielem,5) = mid + (2*ix+1) + (iz+1) * (2*m_nelx(iy) ); out(ielem,6) = top + ( ix+1) + (iz+1) * ( m_nelx(iy)+1); out(ielem,7) = top + ( ix ) + (iz+1) * ( m_nelx(iy)+1); ielem++; } } } // - define connectivity: refinement along the z-direction (below the middle layer) else if ( m_refine(iy) == 2 and iy <= (nely-1)/2 ) { for ( size_t iz = 0 ; iz < m_nelz(iy) ; ++iz ) { for ( size_t ix = 0 ; ix < m_nelx(iy) ; ++ix ) { // -- bottom element out(ielem,0) = bot + (ix ) + iz * (m_nelx(iy)+1); out(ielem,1) = bot + (ix+1) + iz * (m_nelx(iy)+1); out(ielem,2) = bot + (ix+1) + ( iz+1) * (m_nelx(iy)+1); out(ielem,3) = bot + (ix ) + ( iz+1) * (m_nelx(iy)+1); out(ielem,4) = mid + (ix ) + 2*iz * (m_nelx(iy)+1); out(ielem,5) = mid + (ix+1) + 2*iz * (m_nelx(iy)+1); out(ielem,6) = mid + (ix+1) + (2*iz+1) * (m_nelx(iy)+1); out(ielem,7) = mid + (ix ) + (2*iz+1) * (m_nelx(iy)+1); ielem++; // -- top-back element out(ielem,0) = mid + (ix ) + (2*iz+1) * (m_nelx(iy)+1); out(ielem,1) = mid + (ix+1) + (2*iz+1) * (m_nelx(iy)+1); out(ielem,2) = top + (ix+1) + (3*iz+2) * (m_nelx(iy)+1); out(ielem,3) = top + (ix ) + (3*iz+2) * (m_nelx(iy)+1); out(ielem,4) = bot + (ix ) + ( iz+1) * (m_nelx(iy)+1); out(ielem,5) = bot + (ix+1) + ( iz+1) * (m_nelx(iy)+1); out(ielem,6) = top + (ix+1) + (3*iz+3) * (m_nelx(iy)+1); out(ielem,7) = top + (ix ) + (3*iz+3) * (m_nelx(iy)+1); ielem++; // -- top-center element out(ielem,0) = mid + (ix ) + (2*iz ) * (m_nelx(iy)+1); out(ielem,1) = mid + (ix+1) + (2*iz ) * (m_nelx(iy)+1); out(ielem,2) = top + (ix+1) + (3*iz+1) * (m_nelx(iy)+1); out(ielem,3) = top + (ix ) + (3*iz+1) * (m_nelx(iy)+1); out(ielem,4) = mid + (ix ) + (2*iz+1) * (m_nelx(iy)+1); out(ielem,5) = mid + (ix+1) + (2*iz+1) * (m_nelx(iy)+1); out(ielem,6) = top + (ix+1) + (3*iz+2) * (m_nelx(iy)+1); out(ielem,7) = top + (ix ) + (3*iz+2) * (m_nelx(iy)+1); ielem++; // -- top-front element out(ielem,0) = bot + (ix ) + ( iz ) * (m_nelx(iy)+1); out(ielem,1) = bot + (ix+1) + ( iz ) * (m_nelx(iy)+1); out(ielem,2) = top + (ix+1) + (3*iz ) * (m_nelx(iy)+1); out(ielem,3) = top + (ix ) + (3*iz ) * (m_nelx(iy)+1); out(ielem,4) = mid + (ix ) + (2*iz ) * (m_nelx(iy)+1); out(ielem,5) = mid + (ix+1) + (2*iz ) * (m_nelx(iy)+1); out(ielem,6) = top + (ix+1) + (3*iz+1) * (m_nelx(iy)+1); out(ielem,7) = top + (ix ) + (3*iz+1) * (m_nelx(iy)+1); ielem++; } } } // - define connectivity: coarsening along the z-direction (above the middle layer) else if ( m_refine(iy) == 2 and iy > (nely-1)/2 ) { for ( size_t iz = 0 ; iz < m_nelz(iy) ; ++iz ) { for ( size_t ix = 0 ; ix < m_nelx(iy) ; ++ix ) { // -- bottom-front element out(ielem,0) = bot + (ix ) + (3*iz ) * (m_nelx(iy)+1); out(ielem,1) = bot + (ix+1) + (3*iz ) * (m_nelx(iy)+1); out(ielem,2) = top + (ix+1) + ( iz ) * (m_nelx(iy)+1); out(ielem,3) = top + (ix ) + ( iz ) * (m_nelx(iy)+1); out(ielem,4) = bot + (ix ) + (3*iz+1) * (m_nelx(iy)+1); out(ielem,5) = bot + (ix+1) + (3*iz+1) * (m_nelx(iy)+1); out(ielem,6) = mid + (ix+1) + (2*iz ) * (m_nelx(iy)+1); out(ielem,7) = mid + (ix ) + (2*iz ) * (m_nelx(iy)+1); ielem++; // -- bottom-center element out(ielem,0) = bot + (ix ) + (3*iz+1) * (m_nelx(iy)+1); out(ielem,1) = bot + (ix+1) + (3*iz+1) * (m_nelx(iy)+1); out(ielem,2) = mid + (ix+1) + (2*iz ) * (m_nelx(iy)+1); out(ielem,3) = mid + (ix ) + (2*iz ) * (m_nelx(iy)+1); out(ielem,4) = bot + (ix ) + (3*iz+2) * (m_nelx(iy)+1); out(ielem,5) = bot + (ix+1) + (3*iz+2) * (m_nelx(iy)+1); out(ielem,6) = mid + (ix+1) + (2*iz+1) * (m_nelx(iy)+1); out(ielem,7) = mid + (ix ) + (2*iz+1) * (m_nelx(iy)+1); ielem++; // -- bottom-back element out(ielem,0) = bot + (ix ) + (3*iz+2) * (m_nelx(iy)+1); out(ielem,1) = bot + (ix+1) + (3*iz+2) * (m_nelx(iy)+1); out(ielem,2) = mid + (ix+1) + (2*iz+1) * (m_nelx(iy)+1); out(ielem,3) = mid + (ix ) + (2*iz+1) * (m_nelx(iy)+1); out(ielem,4) = bot + (ix ) + (3*iz+3) * (m_nelx(iy)+1); out(ielem,5) = bot + (ix+1) + (3*iz+3) * (m_nelx(iy)+1); out(ielem,6) = top + (ix+1) + ( iz+1) * (m_nelx(iy)+1); out(ielem,7) = top + (ix ) + ( iz+1) * (m_nelx(iy)+1); ielem++; // -- top element out(ielem,0) = mid + (ix ) + (2*iz ) * (m_nelx(iy)+1); out(ielem,1) = mid + (ix+1) + (2*iz ) * (m_nelx(iy)+1); out(ielem,2) = top + (ix+1) + ( iz ) * (m_nelx(iy)+1); out(ielem,3) = top + (ix ) + ( iz ) * (m_nelx(iy)+1); out(ielem,4) = mid + (ix ) + (2*iz+1) * (m_nelx(iy)+1); out(ielem,5) = mid + (ix+1) + (2*iz+1) * (m_nelx(iy)+1); out(ielem,6) = top + (ix+1) + ( iz+1) * (m_nelx(iy)+1); out(ielem,7) = top + (ix ) + ( iz+1) * (m_nelx(iy)+1); ielem++; } } } } return out; } // ------------------------------ node-numbers along the front plane ------------------------------- inline ColS FineLayer::nodesFront() { // number of element layers in y-direction size_t nely = static_cast(m_nhy.size()); - // total number of nodes along this plane + // number of boundary nodes // - initialize size_t n = 0; // - bottom half: bottom node layer (+ middle node layer) for ( size_t iy = 0 ; iy < (nely+1)/2 ; ++iy ) { if ( m_refine(iy) == 0 ) n += m_nelx(iy) * 3 + 1; else n += m_nelx(iy) + 1; } // - top half: (middle node layer +) top node layer for ( size_t iy = (nely-1)/2 ; iy < nely ; ++iy ) { if ( m_refine(iy) == 0 ) n += m_nelx(iy) * 3 + 1; else n += m_nelx(iy) + 1; } // allocate node-list ColS out(n); // initialize counter: current index in the node-list "out" size_t j = 0; // bottom half: bottom node layer (+ middle node layer) for ( size_t iy = 0 ; iy < (nely+1)/2 ; ++iy ) { // -- bottom node layer for ( size_t ix = 0 ; ix < m_nelx(iy)+1 ; ++ix ) { out(j) = m_startNode(iy) + ix; ++j; } - // -- all nodes from the refinement layer + // -- refinement layer if ( m_refine(iy) == 0 ) { for ( size_t ix = 0 ; ix < 2*m_nelx(iy) ; ++ix ) { out(j) = m_startNode(iy) + ix + m_nnd(iy); ++j; } } } // top half: (middle node layer +) top node layer for ( size_t iy = (nely-1)/2 ; iy < nely ; ++iy ) { - // -- all nodes from the refinement layer + // -- refinement layer if ( m_refine(iy) == 0 ) { for ( size_t ix = 0 ; ix < 2*m_nelx(iy) ; ++ix ) { out(j) = m_startNode(iy) + ix + m_nnd(iy); ++j; } } - // -- top node layer: all nodes except the edge nodes + // -- top node layer for ( size_t ix = 0 ; ix < m_nelx(iy)+1 ; ++ix ) { out(j) = m_startNode(iy+1) + ix; ++j; } } return out; } // ------------------------------- node-numbers along the back plane ------------------------------- inline ColS FineLayer::nodesBack() { // number of element layers in y-direction size_t nely = static_cast(m_nhy.size()); - // total number of nodes along this plane + // number of boundary nodes // - initialize size_t n = 0; // - bottom half: bottom node layer (+ middle node layer) for ( size_t iy = 0 ; iy < (nely+1)/2 ; ++iy ) { if ( m_refine(iy) == 0 ) n += m_nelx(iy) * 3 + 1; else n += m_nelx(iy) + 1; } // - top half: (middle node layer +) top node layer for ( size_t iy = (nely-1)/2 ; iy < nely ; ++iy ) { if ( m_refine(iy) == 0 ) n += m_nelx(iy) * 3 + 1; else n += m_nelx(iy) + 1; } // allocate node-list ColS out(n); // initialize counter: current index in the node-list "out" size_t j = 0; // bottom half: bottom node layer (+ middle node layer) for ( size_t iy = 0 ; iy < (nely+1)/2 ; ++iy ) { // -- bottom node layer for ( size_t ix = 0 ; ix < m_nelx(iy)+1 ; ++ix ) { out(j) = m_startNode(iy) + ix + (m_nelx(iy)+1)*m_nelz(iy); ++j; } - // -- all nodes from the refinement layer + // -- refinement layer if ( m_refine(iy) == 0 ) { for ( size_t ix = 0 ; ix < 2*m_nelx(iy) ; ++ix ) { - out(j) = m_startNode(iy) + m_nnd(iy) + ix + 2*m_nelx(iy)*m_nelz(iy); + out(j) = m_startNode(iy) + ix + m_nnd(iy) + 2*m_nelx(iy)*m_nelz(iy); ++j; } } } // top half: (middle node layer +) top node layer for ( size_t iy = (nely-1)/2 ; iy < nely ; ++iy ) { - // -- all nodes from the refinement layer + // -- refinement layer if ( m_refine(iy) == 0 ) { for ( size_t ix = 0 ; ix < 2*m_nelx(iy) ; ++ix ) { - out(j) = m_startNode(iy) + m_nnd(iy) + ix + 2*m_nelx(iy)*m_nelz(iy); + out(j) = m_startNode(iy) + ix + m_nnd(iy) + 2*m_nelx(iy)*m_nelz(iy); ++j; } } - // -- top node layer: all nodes except the edge nodes + // -- top node layer for ( size_t ix = 0 ; ix < m_nelx(iy)+1 ; ++ix ) { out(j) = m_startNode(iy+1) + ix + (m_nelx(iy)+1)*m_nelz(iy); ++j; } } return out; } // ------------------------------- node-numbers along the left plane ------------------------------- inline ColS FineLayer::nodesLeft() { // number of element layers in y-direction size_t nely = static_cast(m_nhy.size()); - // total number of nodes along this plane + // number of boundary nodes // - initialize size_t n = 0; // - bottom half: bottom node layer (+ middle node layer) for ( size_t iy = 0 ; iy < (nely+1)/2 ; ++iy ) { if ( m_refine(iy) == 2 ) n += m_nelz(iy) * 3 + 1; else n += m_nelz(iy) + 1; } // - top half: (middle node layer +) top node layer for ( size_t iy = (nely-1)/2 ; iy < nely ; ++iy ) { if ( m_refine(iy) == 2 ) n += m_nelz(iy) * 3 + 1; else n += m_nelz(iy) + 1; } // allocate node-list ColS out(n); // initialize counter: current index in the node-list "out" size_t j = 0; // bottom half: bottom node layer (+ middle node layer) for ( size_t iy = 0 ; iy < (nely+1)/2 ; ++iy ) { // -- bottom node layer for ( size_t iz = 0 ; iz < m_nelz(iy)+1 ; ++iz ) { out(j) = m_startNode(iy) + iz * (m_nelx(iy)+1); ++j; } - // -- all nodes from the refinement layer + // -- refinement layer if ( m_refine(iy) == 2 ) { for ( size_t iz = 0 ; iz < 2*m_nelz(iy) ; ++iz ) { - out(j) = m_startNode(iy) + m_nnd(iy) + iz * (m_nelx(iy)+1); + out(j) = m_startNode(iy) + iz * (m_nelx(iy)+1) + m_nnd(iy); ++j; } } } // top half: (middle node layer +) top node layer for ( size_t iy = (nely-1)/2 ; iy < nely ; ++iy ) { - // -- all nodes from the refinement layer + // -- refinement layer if ( m_refine(iy) == 2 ) { for ( size_t iz = 0 ; iz < 2*m_nelz(iy) ; ++iz ) { - out(j) = m_startNode(iy) + m_nnd(iy) + iz * (m_nelx(iy)+1); + out(j) = m_startNode(iy) + iz * (m_nelx(iy)+1) + m_nnd(iy); ++j; } } - // -- top node layer: all nodes except the edge nodes + // -- top node layer for ( size_t iz = 0 ; iz < m_nelz(iy)+1 ; ++iz ) { out(j) = m_startNode(iy+1) + iz * (m_nelx(iy)+1); ++j; } } return out; } // ------------------------------ node-numbers along the right plane ------------------------------- inline ColS FineLayer::nodesRight() { // number of element layers in y-direction size_t nely = static_cast(m_nhy.size()); - // total number of nodes along this plane + // number of boundary nodes // - initialize size_t n = 0; // - bottom half: bottom node layer (+ middle node layer) for ( size_t iy = 0 ; iy < (nely+1)/2 ; ++iy ) { if ( m_refine(iy) == 2 ) n += m_nelz(iy) * 3 + 1; else n += m_nelz(iy) + 1; } // - top half: (middle node layer +) top node layer for ( size_t iy = (nely-1)/2 ; iy < nely ; ++iy ) { if ( m_refine(iy) == 2 ) n += m_nelz(iy) * 3 + 1; else n += m_nelz(iy) + 1; } // allocate node-list ColS out(n); // initialize counter: current index in the node-list "out" size_t j = 0; // bottom half: bottom node layer (+ middle node layer) for ( size_t iy = 0 ; iy < (nely+1)/2 ; ++iy ) { // -- bottom node layer for ( size_t iz = 0 ; iz < m_nelz(iy)+1 ; ++iz ) { out(j) = m_startNode(iy) + iz * (m_nelx(iy)+1) + m_nelx(iy); ++j; } - // -- all nodes from the refinement layer + // -- refinement layer if ( m_refine(iy) == 2 ) { for ( size_t iz = 0 ; iz < 2*m_nelz(iy) ; ++iz ) { out(j) = m_startNode(iy) + m_nnd(iy) + iz * (m_nelx(iy)+1) + m_nelx(iy); ++j; } } } // top half: (middle node layer +) top node layer for ( size_t iy = (nely-1)/2 ; iy < nely ; ++iy ) { - // -- all nodes from the refinement layer + // -- refinement layer if ( m_refine(iy) == 2 ) { for ( size_t iz = 0 ; iz < 2*m_nelz(iy) ; ++iz ) { out(j) = m_startNode(iy) + m_nnd(iy) + iz * (m_nelx(iy)+1) + m_nelx(iy); ++j; } } - // -- top node layer: all nodes except the edge nodes + // -- top node layer for ( size_t iz = 0 ; iz < m_nelz(iy)+1 ; ++iz ) { out(j) = m_startNode(iy+1) + iz * (m_nelx(iy)+1) + m_nelx(iy); ++j; } } return out; } // ------------------------------ node-numbers along the bottom plane ------------------------------ inline ColS FineLayer::nodesBottom() { // number of element layers in y-direction size_t nely = static_cast(m_nhy.size()); // allocate node list ColS out(m_nnd(nely)); // counter size_t j = 0; // fill node list for ( size_t ix = 0 ; ix < m_nelx(0)+1 ; ++ix ) { for ( size_t iz = 0 ; iz < m_nelz(0)+1 ; ++iz ) { out(j) = m_startNode(0) + ix + iz * (m_nelx(0)+1); ++j; } } return out; } // ------------------------------- node-numbers along the top plane -------------------------------- inline ColS FineLayer::nodesTop() { // number of element layers in y-direction size_t nely = static_cast(m_nhy.size()); // allocate node list ColS out(m_nnd(nely)); // counter size_t j = 0; // fill node list for ( size_t ix = 0 ; ix < m_nelx(nely-1)+1 ; ++ix ) { for ( size_t iz = 0 ; iz < m_nelz(nely-1)+1 ; ++iz ) { out(j) = m_startNode(nely) + ix + iz * (m_nelx(nely-1)+1); ++j; } } return out; } // ------------------------------- node-numbers along the front face ------------------------------- inline ColS FineLayer::nodesFrontFace() { // number of element layers in y-direction size_t nely = static_cast(m_nhy.size()); - // total number of face nodes + // number of boundary nodes // - initialize size_t n = 0; // - bottom half: bottom node layer (+ middle node layer) for ( size_t iy = 1 ; iy < (nely+1)/2 ; ++iy ) { if ( m_refine(iy) == 0 ) n += m_nelx(iy) * 3 - 1; else n += m_nelx(iy) - 1; } // - top half: (middle node layer +) top node layer for ( size_t iy = (nely-1)/2 ; iy < nely-1 ; ++iy ) { if ( m_refine(iy) == 0 ) n += m_nelx(iy) * 3 - 1; else n += m_nelx(iy) - 1; } // allocate node-list ColS out(n); // initialize counter: current index in the node-list "out" size_t j = 0; // bottom half: bottom node layer (+ middle node layer) for ( size_t iy = 1 ; iy < (nely+1)/2 ; ++iy ) { // -- bottom node layer for ( size_t ix = 1 ; ix < m_nelx(iy) ; ++ix ) { out(j) = m_startNode(iy) + ix; ++j; } - // -- all nodes from the refinement layer + // -- refinement layer if ( m_refine(iy) == 0 ) { for ( size_t ix = 0 ; ix < 2*m_nelx(iy) ; ++ix ) { out(j) = m_startNode(iy) + ix + m_nnd(iy); ++j; } } } // top half: (middle node layer +) top node layer for ( size_t iy = (nely-1)/2 ; iy < nely-1 ; ++iy ) { - // -- all nodes from the refinement layer + // -- refinement layer if ( m_refine(iy) == 0 ) { for ( size_t ix = 0 ; ix < 2*m_nelx(iy) ; ++ix ) { out(j) = m_startNode(iy) + ix + m_nnd(iy); ++j; } } - // -- top node layer: all nodes except the edge nodes + // -- top node layer for ( size_t ix = 1 ; ix < m_nelx(iy) ; ++ix ) { out(j) = m_startNode(iy+1) + ix; ++j; } } return out; } // ------------------------------- node-numbers along the back face -------------------------------- inline ColS FineLayer::nodesBackFace() { // number of element layers in y-direction size_t nely = static_cast(m_nhy.size()); - // total number of face nodes + // number of boundary nodes // - initialize size_t n = 0; // - bottom half: bottom node layer (+ middle node layer) for ( size_t iy = 1 ; iy < (nely+1)/2 ; ++iy ) { if ( m_refine(iy) == 0 ) n += m_nelx(iy) * 3 - 1; else n += m_nelx(iy) - 1; } // - top half: (middle node layer +) top node layer for ( size_t iy = (nely-1)/2 ; iy < nely-1 ; ++iy ) { if ( m_refine(iy) == 0 ) n += m_nelx(iy) * 3 - 1; else n += m_nelx(iy) - 1; } // allocate node-list ColS out(n); // initialize counter: current index in the node-list "out" size_t j = 0; // bottom half: bottom node layer (+ middle node layer) for ( size_t iy = 1 ; iy < (nely+1)/2 ; ++iy ) { // -- bottom node layer for ( size_t ix = 1 ; ix < m_nelx(iy) ; ++ix ) { out(j) = m_startNode(iy) + ix + (m_nelx(iy)+1)*m_nelz(iy); ++j; } - // -- all nodes from the refinement layer + // -- refinement layer if ( m_refine(iy) == 0 ) { for ( size_t ix = 0 ; ix < 2*m_nelx(iy) ; ++ix ) { - out(j) = m_startNode(iy) + ix + 2*m_nelx(iy)*m_nelz(iy) + m_nnd(iy); + out(j) = m_startNode(iy) + ix + m_nnd(iy) + 2*m_nelx(iy)*m_nelz(iy); ++j; } } } // top half: (middle node layer +) top node layer for ( size_t iy = (nely-1)/2 ; iy < nely-1 ; ++iy ) { - // -- all nodes from the refinement layer + // -- refinement layer if ( m_refine(iy) == 0 ) { for ( size_t ix = 0 ; ix < 2*m_nelx(iy) ; ++ix ) { - out(j) = m_startNode(iy) + ix + 2*m_nelx(iy)*m_nelz(iy) + m_nnd(iy); + out(j) = m_startNode(iy) + ix + m_nnd(iy) + 2*m_nelx(iy)*m_nelz(iy); ++j; } } - // -- top node layer: all nodes except the edge nodes + // -- top node layer for ( size_t ix = 1 ; ix < m_nelx(iy) ; ++ix ) { out(j) = m_startNode(iy+1) + ix + (m_nelx(iy)+1)*m_nelz(iy); ++j; } } return out; } // ------------------------------- node-numbers along the left face -------------------------------- inline ColS FineLayer::nodesLeftFace() { // number of element layers in y-direction size_t nely = static_cast(m_nhy.size()); - // total number of nodes along this plane + // number of boundary nodes // - initialize size_t n = 0; // - bottom half: bottom node layer (+ middle node layer) for ( size_t iy = 1 ; iy < (nely+1)/2 ; ++iy ) { if ( m_refine(iy) == 2 ) n += m_nelz(iy) * 3 - 1; else n += m_nelz(iy) - 1; } // - top half: (middle node layer +) top node layer for ( size_t iy = (nely-1)/2 ; iy < nely-1 ; ++iy ) { if ( m_refine(iy) == 2 ) n += m_nelz(iy) * 3 - 1; else n += m_nelz(iy) - 1; } // allocate node-list ColS out(n); - out.setConstant(0); - // initialize counter: current index in the node-list "out" size_t j = 0; // bottom half: bottom node layer (+ middle node layer) for ( size_t iy = 1 ; iy < (nely+1)/2 ; ++iy ) { // -- bottom node layer for ( size_t iz = 1 ; iz < m_nelz(iy) ; ++iz ) { out(j) = m_startNode(iy) + iz * (m_nelx(iy)+1); ++j; } - // -- all nodes from the refinement layer + // -- refinement layer if ( m_refine(iy) == 2 ) { for ( size_t iz = 0 ; iz < 2*m_nelz(iy) ; ++iz ) { - out(j) = m_startNode(iy) + m_nnd(iy) + iz * (m_nelx(iy)+1); + out(j) = m_startNode(iy) + iz * (m_nelx(iy)+1) + m_nnd(iy); ++j; } } } // top half: (middle node layer +) top node layer for ( size_t iy = (nely-1)/2 ; iy < nely-1 ; ++iy ) { - // -- all nodes from the refinement layer + // -- refinement layer if ( m_refine(iy) == 2 ) { for ( size_t iz = 0 ; iz < 2*m_nelz(iy) ; ++iz ) { - out(j) = m_startNode(iy) + m_nnd(iy) + iz * (m_nelx(iy)+1); + out(j) = m_startNode(iy) + iz * (m_nelx(iy)+1) + m_nnd(iy); ++j; } } - // -- top node layer: all nodes except the edge nodes + // -- top node layer for ( size_t iz = 1 ; iz < m_nelz(iy) ; ++iz ) { out(j) = m_startNode(iy+1) + iz * (m_nelx(iy)+1); ++j; } } return out; } // ------------------------------- node-numbers along the right face ------------------------------- inline ColS FineLayer::nodesRightFace() { // number of element layers in y-direction size_t nely = static_cast(m_nhy.size()); - // total number of nodes along this plane + // number of boundary nodes // - initialize size_t n = 0; // - bottom half: bottom node layer (+ middle node layer) for ( size_t iy = 1 ; iy < (nely+1)/2 ; ++iy ) { if ( m_refine(iy) == 2 ) n += m_nelz(iy) * 3 - 1; else n += m_nelz(iy) - 1; } // - top half: (middle node layer +) top node layer for ( size_t iy = (nely-1)/2 ; iy < nely-1 ; ++iy ) { if ( m_refine(iy) == 2 ) n += m_nelz(iy) * 3 - 1; else n += m_nelz(iy) - 1; } // allocate node-list ColS out(n); - out.setConstant(0); - // initialize counter: current index in the node-list "out" size_t j = 0; // bottom half: bottom node layer (+ middle node layer) for ( size_t iy = 1 ; iy < (nely+1)/2 ; ++iy ) { // -- bottom node layer for ( size_t iz = 1 ; iz < m_nelz(iy) ; ++iz ) { out(j) = m_startNode(iy) + iz * (m_nelx(iy)+1) + m_nelx(iy); ++j; } - // -- all nodes from the refinement layer + // -- refinement layer if ( m_refine(iy) == 2 ) { for ( size_t iz = 0 ; iz < 2*m_nelz(iy) ; ++iz ) { out(j) = m_startNode(iy) + m_nnd(iy) + iz * (m_nelx(iy)+1) + m_nelx(iy); ++j; } } } // top half: (middle node layer +) top node layer for ( size_t iy = (nely-1)/2 ; iy < nely-1 ; ++iy ) { - // -- all nodes from the refinement layer + // -- refinement layer if ( m_refine(iy) == 2 ) { for ( size_t iz = 0 ; iz < 2*m_nelz(iy) ; ++iz ) { out(j) = m_startNode(iy) + m_nnd(iy) + iz * (m_nelx(iy)+1) + m_nelx(iy); ++j; } } - // -- top node layer: all nodes except the edge nodes + // -- top node layer for ( size_t iz = 1 ; iz < m_nelz(iy) ; ++iz ) { out(j) = m_startNode(iy+1) + iz * (m_nelx(iy)+1) + m_nelx(iy); ++j; } } return out; } // ------------------------------ node-numbers along the bottom face ------------------------------- inline ColS FineLayer::nodesBottomFace() { // allocate node list ColS out((m_nelx(0)-1)*(m_nelz(0)-1)); // counter size_t j = 0; // fill node list for ( size_t ix = 1 ; ix < m_nelx(0) ; ++ix ) { for ( size_t iz = 1 ; iz < m_nelz(0) ; ++iz ) { out(j) = m_startNode(0) + ix + iz * (m_nelx(0)+1); ++j; } } return out; } // -------------------------------- node-numbers along the top face -------------------------------- inline ColS FineLayer::nodesTopFace() { // number of element layers in y-direction size_t nely = static_cast(m_nhy.size()); // allocate node list ColS out((m_nelx(nely-1)-1)*(m_nelz(nely-1)-1)); // counter size_t j = 0; // fill node list for ( size_t ix = 1 ; ix < m_nelx(nely-1) ; ++ix ) { for ( size_t iz = 1 ; iz < m_nelz(nely-1) ; ++iz ) { out(j) = m_startNode(nely) + ix + iz * (m_nelx(nely-1)+1); ++j; } } return out; } // --------------------------- node-numbers along the front-bottom edge ---------------------------- inline ColS FineLayer::nodesFrontBottomEdge() { ColS out(m_nelx(0)+1); for ( size_t ix = 0 ; ix < m_nelx(0)+1 ; ++ix ) out(ix) = m_startNode(0) + ix; return out; } // ----------------------------- node-numbers along the front-top edge ----------------------------- inline ColS FineLayer::nodesFrontTopEdge() { size_t nely = static_cast(m_nhy.size()); ColS out(m_nelx(nely-1)+1); for ( size_t ix = 0 ; ix < m_nelx(nely-1)+1 ; ++ix ) out(ix) = m_startNode(nely) + ix; return out; } // ---------------------------- node-numbers along the front-left edge ----------------------------- inline ColS FineLayer::nodesFrontLeftEdge() { size_t nely = static_cast(m_nhy.size()); ColS out(nely+1); for ( size_t iy = 0 ; iy < (nely+1)/2 ; ++iy ) out(iy) = m_startNode(iy); for ( size_t iy = (nely-1)/2 ; iy < nely ; ++iy ) out(iy+1) = m_startNode(iy+1); return out; } // ---------------------------- node-numbers along the front-right edge ---------------------------- inline ColS FineLayer::nodesFrontRightEdge() { size_t nely = static_cast(m_nhy.size()); ColS out(nely+1); for ( size_t iy = 0 ; iy < (nely+1)/2 ; ++iy ) out(iy) = m_startNode(iy) + m_nelx(iy); for ( size_t iy = (nely-1)/2 ; iy < nely ; ++iy ) out(iy+1) = m_startNode(iy+1) + m_nelx(iy); return out; } // ---------------------------- node-numbers along the back-bottom edge ---------------------------- inline ColS FineLayer::nodesBackBottomEdge() { ColS out(m_nelx(0)+1); for ( size_t ix = 0 ; ix < m_nelx(0)+1 ; ++ix ) out(ix) = m_startNode(0) + ix + (m_nelx(0)+1)*(m_nelz(0)); return out; } // ----------------------------- node-numbers along the back-top edge ------------------------------ inline ColS FineLayer::nodesBackTopEdge() { size_t nely = static_cast(m_nhy.size()); ColS out(m_nelx(nely-1)+1); for ( size_t ix = 0 ; ix < m_nelx(nely-1)+1 ; ++ix ) out(ix) = m_startNode(nely) + ix + (m_nelx(nely-1)+1)*(m_nelz(nely-1)); return out; } // ----------------------------- node-numbers along the back-left edge ----------------------------- inline ColS FineLayer::nodesBackLeftEdge() { size_t nely = static_cast(m_nhy.size()); ColS out(nely+1); for ( size_t iy = 0 ; iy < (nely+1)/2 ; ++iy ) out(iy) = m_startNode(iy) + (m_nelx(iy)+1)*(m_nelz(iy)); for ( size_t iy = (nely-1)/2 ; iy < nely ; ++iy ) out(iy+1) = m_startNode(iy+1) + (m_nelx(iy)+1)*(m_nelz(iy)); return out; } // ---------------------------- node-numbers along the back-right edge ----------------------------- inline ColS FineLayer::nodesBackRightEdge() { size_t nely = static_cast(m_nhy.size()); ColS out(nely+1); for ( size_t iy = 0 ; iy < (nely+1)/2 ; ++iy ) out(iy) = m_startNode(iy) + m_nelx(iy) + (m_nelx(iy)+1)*(m_nelz(iy)); for ( size_t iy = (nely-1)/2 ; iy < nely ; ++iy ) out(iy+1) = m_startNode(iy+1) + m_nelx(iy) + (m_nelx(iy)+1)*(m_nelz(iy)); return out; } // ---------------------------- node-numbers along the bottom-left edge ---------------------------- inline ColS FineLayer::nodesBottomLeftEdge() { ColS out(m_nelz(0)+1); for ( size_t iz = 0 ; iz < m_nelz(0)+1 ; ++iz ) out(iz) = m_startNode(0) + iz * (m_nelx(0)+1); return out; } // --------------------------- node-numbers along the bottom-right edge ---------------------------- inline ColS FineLayer::nodesBottomRightEdge() { ColS out(m_nelz(0)+1); for ( size_t iz = 0 ; iz < m_nelz(0)+1 ; ++iz ) out(iz) = m_startNode(0) + m_nelx(0) + iz * (m_nelx(0)+1); return out; } // ----------------------------- node-numbers along the top-left edge ------------------------------ inline ColS FineLayer::nodesTopLeftEdge() { size_t nely = static_cast(m_nhy.size()); ColS out(m_nelz(nely-1)+1); for ( size_t iz = 0 ; iz < m_nelz(nely-1)+1 ; ++iz ) out(iz) = m_startNode(nely) + iz * (m_nelx(nely-1)+1); return out; } // ----------------------------- node-numbers along the top-right edge ----------------------------- inline ColS FineLayer::nodesTopRightEdge() { size_t nely = static_cast(m_nhy.size()); ColS out(m_nelz(nely-1)+1); for ( size_t iz = 0 ; iz < m_nelz(nely-1)+1 ; ++iz ) out(iz) = m_startNode(nely) + m_nelx(nely-1) + iz * (m_nelx(nely-1)+1); return out; } - - - - // ------------------- node-numbers along the front-bottom edge, without corners ------------------- inline ColS FineLayer::nodesFrontBottomOpenEdge() { ColS out(m_nelx(0)-1); for ( size_t ix = 1 ; ix < m_nelx(0) ; ++ix ) out(ix-1) = m_startNode(0) + ix; return out; } // -------------------- node-numbers along the front-top edge, without corners --------------------- inline ColS FineLayer::nodesFrontTopOpenEdge() { size_t nely = static_cast(m_nhy.size()); ColS out(m_nelx(nely-1)-1); for ( size_t ix = 1 ; ix < m_nelx(nely-1) ; ++ix ) out(ix-1) = m_startNode(nely) + ix; return out; } // -------------------- node-numbers along the front-left edge, without corners -------------------- inline ColS FineLayer::nodesFrontLeftOpenEdge() { size_t nely = static_cast(m_nhy.size()); ColS out(nely-1); for ( size_t iy = 1 ; iy < (nely+1)/2 ; ++iy ) out(iy-1) = m_startNode(iy); for ( size_t iy = (nely-1)/2 ; iy < nely-1 ; ++iy ) out(iy) = m_startNode(iy+1); return out; } // ------------------- node-numbers along the front-right edge, without corners -------------------- inline ColS FineLayer::nodesFrontRightOpenEdge() { size_t nely = static_cast(m_nhy.size()); ColS out(nely-1); for ( size_t iy = 1 ; iy < (nely+1)/2 ; ++iy ) out(iy-1) = m_startNode(iy) + m_nelx(iy); for ( size_t iy = (nely-1)/2 ; iy < nely-1 ; ++iy ) out(iy) = m_startNode(iy+1) + m_nelx(iy); return out; } // ------------------- node-numbers along the back-bottom edge, without corners -------------------- inline ColS FineLayer::nodesBackBottomOpenEdge() { ColS out(m_nelx(0)-1); for ( size_t ix = 1 ; ix < m_nelx(0) ; ++ix ) out(ix-1) = m_startNode(0) + ix + (m_nelx(0)+1)*(m_nelz(0)); return out; } // --------------------- node-numbers along the back-top edge, without corners --------------------- inline ColS FineLayer::nodesBackTopOpenEdge() { size_t nely = static_cast(m_nhy.size()); ColS out(m_nelx(nely-1)-1); for ( size_t ix = 1 ; ix < m_nelx(nely-1) ; ++ix ) out(ix-1) = m_startNode(nely) + ix + (m_nelx(nely-1)+1)*(m_nelz(nely-1)); return out; } // -------------------- node-numbers along the back-left edge, without corners --------------------- inline ColS FineLayer::nodesBackLeftOpenEdge() { size_t nely = static_cast(m_nhy.size()); ColS out(nely-1); for ( size_t iy = 1 ; iy < (nely+1)/2 ; ++iy ) out(iy-1) = m_startNode(iy) + (m_nelx(iy)+1)*(m_nelz(iy)); for ( size_t iy = (nely-1)/2 ; iy < nely-1 ; ++iy ) out(iy) = m_startNode(iy+1) + (m_nelx(iy)+1)*(m_nelz(iy)); return out; } // -------------------- node-numbers along the back-right edge, without corners -------------------- inline ColS FineLayer::nodesBackRightOpenEdge() { size_t nely = static_cast(m_nhy.size()); ColS out(nely-1); for ( size_t iy = 1 ; iy < (nely+1)/2 ; ++iy ) out(iy-1) = m_startNode(iy) + m_nelx(iy) + (m_nelx(iy)+1)*(m_nelz(iy)); for ( size_t iy = (nely-1)/2 ; iy < nely-1 ; ++iy ) out(iy) = m_startNode(iy+1) + m_nelx(iy) + (m_nelx(iy)+1)*(m_nelz(iy)); return out; } // ------------------- node-numbers along the bottom-left edge, without corners -------------------- inline ColS FineLayer::nodesBottomLeftOpenEdge() { ColS out(m_nelz(0)-1); for ( size_t iz = 1 ; iz < m_nelz(0) ; ++iz ) out(iz-1) = m_startNode(0) + iz * (m_nelx(0)+1); return out; } // ------------------- node-numbers along the bottom-right edge, without corners ------------------- inline ColS FineLayer::nodesBottomRightOpenEdge() { ColS out(m_nelz(0)-1); - for ( size_t iz = 1 ; iz < m_nelz(0)-1 ; ++iz ) + for ( size_t iz = 1 ; iz < m_nelz(0) ; ++iz ) out(iz-1) = m_startNode(0) + m_nelx(0) + iz * (m_nelx(0)+1); return out; } // --------------------- node-numbers along the top-left edge, without corners --------------------- inline ColS FineLayer::nodesTopLeftOpenEdge() { size_t nely = static_cast(m_nhy.size()); ColS out(m_nelz(nely-1)-1); - for ( size_t iz = 1 ; iz < m_nelz(nely-1)-1 ; ++iz ) + for ( size_t iz = 1 ; iz < m_nelz(nely-1) ; ++iz ) out(iz-1) = m_startNode(nely) + iz * (m_nelx(nely-1)+1); return out; } // -------------------- node-numbers along the top-right edge, without corners --------------------- inline ColS FineLayer::nodesTopRightOpenEdge() { size_t nely = static_cast(m_nhy.size()); ColS out(m_nelz(nely-1)-1); - for ( size_t iz = 1 ; iz < m_nelz(nely-1)-1 ; ++iz ) + for ( size_t iz = 1 ; iz < m_nelz(nely-1) ; ++iz ) out(iz-1) = m_startNode(nely) + m_nelx(nely-1) + iz * (m_nelx(nely-1)+1); return out; } +// -------------------------- node-number of the front-bottom-left corner -------------------------- + +inline size_t FineLayer::nodesFrontBottomLeftCorner() +{ + return m_startNode(0); +} + +// -------------------------- node-number of the front-bottom-right corner -------------------------- + +inline size_t FineLayer::nodesFrontBottomRightCorner() +{ + return m_startNode(0) + m_nelx(0); +} + +// -------------------------- node-number of the front-top-left corner --------------------------- + +inline size_t FineLayer::nodesFrontTopLeftCorner() +{ + size_t nely = static_cast(m_nhy.size()); + + return m_startNode(nely); +} + +// -------------------------- node-number of the front-top-right corner -------------------------- + +inline size_t FineLayer::nodesFrontTopRightCorner() +{ + size_t nely = static_cast(m_nhy.size()); + + return m_startNode(nely) + m_nelx(nely-1); +} + +// -------------------------- node-number of the back-bottom-left corner -------------------------- + +inline size_t FineLayer::nodesBackBottomLeftCorner() +{ + return m_startNode(0) + (m_nelx(0)+1)*(m_nelz(0)); +} + +// -------------------------- node-number of the back-bottom-right corner -------------------------- + +inline size_t FineLayer::nodesBackBottomRightCorner() +{ + return m_startNode(0) + m_nelx(0) + (m_nelx(0)+1)*(m_nelz(0)); +} + +// -------------------------- node-number of the back-top-left corner --------------------------- + +inline size_t FineLayer::nodesBackTopLeftCorner() +{ + size_t nely = static_cast(m_nhy.size()); + + return m_startNode(nely) + (m_nelx(nely-1)+1)*(m_nelz(nely-1)); +} + +// -------------------------- node-number of the back-top-right corner -------------------------- + +inline size_t FineLayer::nodesBackTopRightCorner() +{ + size_t nely = static_cast(m_nhy.size()); + + return m_startNode(nely) + m_nelx(nely-1) + (m_nelx(nely-1)+1)*(m_nelz(nely-1)); +} + // ================================================================================================= }}} // namespace ... // ================================================================================================= #endif diff --git a/src/GooseFEM/MeshHex8.h b/src/GooseFEM/MeshHex8.h index 196ddcc..a233874 100644 --- a/src/GooseFEM/MeshHex8.h +++ b/src/GooseFEM/MeshHex8.h @@ -1,289 +1,289 @@ /* ================================================================================================= (c - GPLv3) T.W.J. de Geus (Tom) | tom@geus.me | www.geus.me | github.com/tdegeus/GooseFEM ================================================================================================= */ #ifndef GOOSEFEM_MESHHEX8_H #define GOOSEFEM_MESHHEX8_H // ------------------------------------------------------------------------------------------------- #include "Mesh.h" // ===================================== GooseFEM::Mesh::Hex8 ====================================== namespace GooseFEM { namespace Mesh { namespace Hex8 { // ========================================== REGULAR MESH ========================================= class Regular { private: size_t m_nelx; // number of 'pixels' x-direction (length == "m_nelx * m_h") size_t m_nely; // number of 'pixels' y-direction (length == "m_nely * m_h") size_t m_nelz; // number of 'pixels' z-direction (length == "m_nely * m_h") double m_h; // size of the element edge (equal in both directions) size_t m_nelem; // number of elements size_t m_nnode; // number of nodes size_t m_nne=8; // number of nodes-per-element size_t m_ndim=3; // number of dimensions public: // mesh with "nelx*nely*nelz" 'pixels' and edge size "h" Regular(size_t nelx, size_t nely, size_t nelz, double h=1.); // sizes size_t nelem(); // number of elements size_t nnode(); // number of nodes size_t nne(); // number of nodes-per-element size_t ndim(); // number of dimensions // mesh MatD coor(); // nodal positions [ nnode , ndim ] MatS conn(); // connectivity [ nelem , nne ] // boundary nodes: planes ColS nodesFront(); // node-numbers along the front plane ColS nodesBack(); // node-numbers along the back plane ColS nodesLeft(); // node-numbers along the left plane ColS nodesRight(); // node-numbers along the right plane ColS nodesBottom(); // node-numbers along the bottom plane ColS nodesTop(); // node-numbers along the top plane // boundary nodes: faces ColS nodesFrontFace(); // node-numbers along the front face ColS nodesBackFace(); // node-numbers along the back face ColS nodesLeftFace(); // node-numbers along the left face ColS nodesRightFace(); // node-numbers along the right face ColS nodesBottomFace(); // node-numbers along the bottom face ColS nodesTopFace(); // node-numbers along the top face // boundary nodes: edges ColS nodesFrontBottomEdge(); // node-numbers along the front - bottom edge ColS nodesFrontTopEdge(); // node-numbers along the front - top edge ColS nodesFrontLeftEdge(); // node-numbers along the front - left edge ColS nodesFrontRightEdge(); // node-numbers along the front - right edge ColS nodesBackBottomEdge(); // node-numbers along the back - bottom edge ColS nodesBackTopEdge(); // node-numbers along the back - top edge ColS nodesBackLeftEdge(); // node-numbers along the back - left edge ColS nodesBackRightEdge(); // node-numbers along the back - right edge ColS nodesBottomLeftEdge(); // node-numbers along the bottom - left edge ColS nodesBottomRightEdge(); // node-numbers along the bottom - right edge ColS nodesTopLeftEdge(); // node-numbers along the top - left edge ColS nodesTopRightEdge(); // node-numbers along the top - right edge // boundary nodes: edges (aliases) ColS nodesBottomFrontEdge(); // alias, see above: nodesFrontBottomEdge ColS nodesBottomBackEdge(); // alias, see above: nodesBackBottomEdge ColS nodesTopFrontEdge(); // alias, see above: nodesFrontTopEdge ColS nodesTopBackEdge(); // alias, see above: nodesBackTopEdge ColS nodesLeftBottomEdge(); // alias, see above: nodesBottomLeftEdge ColS nodesLeftFrontEdge(); // alias, see above: nodesFrontLeftEdge ColS nodesLeftBackEdge(); // alias, see above: nodesBackLeftEdge ColS nodesLeftTopEdge(); // alias, see above: nodesTopLeftEdge ColS nodesRightBottomEdge(); // alias, see above: nodesBottomRightEdge ColS nodesRightTopEdge(); // alias, see above: nodesTopRightEdge ColS nodesRightFrontEdge(); // alias, see above: nodesFrontRightEdge ColS nodesRightBackEdge(); // alias, see above: nodesBackRightEdge // boundary nodes: corners size_t nodesFrontBottomLeftCorner(); // node-number of the front - bottom - left corner size_t nodesFrontBottomRightCorner(); // node-number of the front - bottom - right corner size_t nodesFrontTopLeftCorner(); // node-number of the front - top - left corner size_t nodesFrontTopRightCorner(); // node-number of the front - top - right corner size_t nodesBackBottomLeftCorner(); // node-number of the back - bottom - left corner size_t nodesBackBottomRightCorner(); // node-number of the back - bottom - right corner size_t nodesBackTopLeftCorner(); // node-number of the back - top - left corner size_t nodesBackTopRightCorner(); // node-number of the back - top - right corner // boundary nodes: corners (aliases) size_t nodesFrontLeftBottomCorner(); // alias, see above: nodesFrontBottomLeftCorner size_t nodesBottomFrontLeftCorner(); // alias, see above: nodesFrontBottomLeftCorner size_t nodesBottomLeftFrontCorner(); // alias, see above: nodesFrontBottomLeftCorner size_t nodesLeftFrontBottomCorner(); // alias, see above: nodesFrontBottomLeftCorner size_t nodesLeftBottomFrontCorner(); // alias, see above: nodesFrontBottomLeftCorner size_t nodesFrontRightBottomCorner(); // alias, see above: nodesFrontBottomRightCorner size_t nodesBottomFrontRightCorner(); // alias, see above: nodesFrontBottomRightCorner size_t nodesBottomRightFrontCorner(); // alias, see above: nodesFrontBottomRightCorner size_t nodesRightFrontBottomCorner(); // alias, see above: nodesFrontBottomRightCorner size_t nodesRightBottomFrontCorner(); // alias, see above: nodesFrontBottomRightCorner size_t nodesFrontLeftTopCorner(); // alias, see above: nodesFrontTopLeftCorner size_t nodesTopFrontLeftCorner(); // alias, see above: nodesFrontTopLeftCorner size_t nodesTopLeftFrontCorner(); // alias, see above: nodesFrontTopLeftCorner size_t nodesLeftFrontTopCorner(); // alias, see above: nodesFrontTopLeftCorner size_t nodesLeftTopFrontCorner(); // alias, see above: nodesFrontTopLeftCorner size_t nodesFrontRightTopCorner(); // alias, see above: nodesFrontTopRightCorner size_t nodesTopFrontRightCorner(); // alias, see above: nodesFrontTopRightCorner size_t nodesTopRightFrontCorner(); // alias, see above: nodesFrontTopRightCorner size_t nodesRightFrontTopCorner(); // alias, see above: nodesFrontTopRightCorner size_t nodesRightTopFrontCorner(); // alias, see above: nodesFrontTopRightCorner size_t nodesBackLeftBottomCorner(); // alias, see above: nodesBackBottomLeftCorner size_t nodesBottomBackLeftCorner(); // alias, see above: nodesBackBottomLeftCorner size_t nodesBottomLeftBackCorner(); // alias, see above: nodesBackBottomLeftCorner size_t nodesLeftBackBottomCorner(); // alias, see above: nodesBackBottomLeftCorner size_t nodesLeftBottomBackCorner(); // alias, see above: nodesBackBottomLeftCorner size_t nodesBackRightBottomCorner(); // alias, see above: nodesBackBottomRightCorner size_t nodesBottomBackRightCorner(); // alias, see above: nodesBackBottomRightCorner size_t nodesBottomRightBackCorner(); // alias, see above: nodesBackBottomRightCorner size_t nodesRightBackBottomCorner(); // alias, see above: nodesBackBottomRightCorner size_t nodesRightBottomBackCorner(); // alias, see above: nodesBackBottomRightCorner size_t nodesBackLeftTopCorner(); // alias, see above: nodesBackTopLeftCorner size_t nodesTopBackLeftCorner(); // alias, see above: nodesBackTopLeftCorner size_t nodesTopLeftBackCorner(); // alias, see above: nodesBackTopLeftCorner size_t nodesLeftBackTopCorner(); // alias, see above: nodesBackTopLeftCorner size_t nodesLeftTopBackCorner(); // alias, see above: nodesBackTopLeftCorner size_t nodesBackRightTopCorner(); // alias, see above: nodesBackTopRightCorner size_t nodesTopBackRightCorner(); // alias, see above: nodesBackTopRightCorner size_t nodesTopRightBackCorner(); // alias, see above: nodesBackTopRightCorner size_t nodesRightBackTopCorner(); // alias, see above: nodesBackTopRightCorner size_t nodesRightTopBackCorner(); // alias, see above: nodesBackTopRightCorner // periodicity MatS nodesPeriodic(); // periodic node pairs [:,2]: (independent, dependent) size_t nodesOrigin(); // front-bottom-left node, used as reference for periodicity MatS dofs(); // DOF-numbers for each component of each node (sequential) MatS dofsPeriodic(); // ,, for the case that the periodicity if fully eliminated }; // ====================== MESH WITH A FINE LAYER THAT EXPONENTIALLY COARSENS ======================= class FineLayer { private: double m_h; // elementary element edge-size (in all directions) double m_Lx, m_Lz; // mesh size in "x" and "z" ColS m_nelx, m_nelz; // number of elements in "x" and "z" (per el.layer in "y") ColS m_nnd; // total number of nodes in the main node layer (per nd.layer in "y") ColS m_nhx, m_nhy, m_nhz; // element size in each direction (per el.layer in "y") ColI m_refine; // refine direction (-1: no refine, 0: "x", ...) (per el.layer in "y") ColS m_startElem; // start element (per el.layer in "y") ColS m_startNode; // start node (per nd.layer in "y") size_t m_nelem; // number of elements size_t m_nnode; // number of nodes size_t m_nne=8; // number of nodes-per-element size_t m_ndim=3; // number of dimensions public: // mesh with "nelx*nely*nelz" 'pixels' of edge size "h"; elements are coarsened in "y"-direction FineLayer(size_t nelx, size_t nely, size_t nelz, double h=1., size_t nfine=1); // sizes size_t nelem(); // number of elements size_t nnode(); // number of nodes size_t nne(); // number of nodes-per-element size_t ndim(); // number of dimensions size_t shape(size_t i); // actual shape in a certain direction // mesh MatD coor(); // nodal positions [nnode ,ndim] MatS conn(); // connectivity [nelem ,nne ] // boundary nodes: planes ColS nodesFront(); // node-numbers along the front plane ColS nodesBack(); // node-numbers along the back plane ColS nodesLeft(); // node-numbers along the left plane ColS nodesRight(); // node-numbers along the right plane ColS nodesBottom(); // node-numbers along the bottom plane ColS nodesTop(); // node-numbers along the top plane // boundary nodes: faces ColS nodesFrontFace(); // node-numbers along the front face ColS nodesBackFace(); // node-numbers along the back face ColS nodesLeftFace(); // node-numbers along the left face ColS nodesRightFace(); // node-numbers along the right face ColS nodesBottomFace(); // node-numbers along the bottom face ColS nodesTopFace(); // node-numbers along the top face // boundary nodes: edges ColS nodesFrontBottomEdge(); // node-numbers along the front - bottom edge ColS nodesFrontTopEdge(); // node-numbers along the front - top edge ColS nodesFrontLeftEdge(); // node-numbers along the front - left edge ColS nodesFrontRightEdge(); // node-numbers along the front - right edge ColS nodesBackBottomEdge(); // node-numbers along the back - bottom edge ColS nodesBackTopEdge(); // node-numbers along the back - top edge ColS nodesBackLeftEdge(); // node-numbers along the back - left edge ColS nodesBackRightEdge(); // node-numbers along the back - right edge ColS nodesBottomLeftEdge(); // node-numbers along the bottom - left edge ColS nodesBottomRightEdge(); // node-numbers along the bottom - right edge ColS nodesTopLeftEdge(); // node-numbers along the top - left edge ColS nodesTopRightEdge(); // node-numbers along the top - right edge // boundary nodes: edges ColS nodesFrontBottomOpenEdge(); // node-numbers along the front - bottom edge ColS nodesFrontTopOpenEdge(); // node-numbers along the front - top edge ColS nodesFrontLeftOpenEdge(); // node-numbers along the front - left edge ColS nodesFrontRightOpenEdge(); // node-numbers along the front - right edge ColS nodesBackBottomOpenEdge(); // node-numbers along the back - bottom edge ColS nodesBackTopOpenEdge(); // node-numbers along the back - top edge ColS nodesBackLeftOpenEdge(); // node-numbers along the back - left edge ColS nodesBackRightOpenEdge(); // node-numbers along the back - right edge ColS nodesBottomLeftOpenEdge(); // node-numbers along the bottom - left edge ColS nodesBottomRightOpenEdge(); // node-numbers along the bottom - right edge ColS nodesTopLeftOpenEdge(); // node-numbers along the top - left edge ColS nodesTopRightOpenEdge(); // node-numbers along the top - right edge // // boundary nodes: edges (aliases) // ColS nodesBottomFrontEdge(); // alias, see above: nodesFrontBottomEdge // ColS nodesBottomBackEdge(); // alias, see above: nodesBackBottomEdge // ColS nodesTopFrontEdge(); // alias, see above: nodesFrontTopEdge // ColS nodesTopBackEdge(); // alias, see above: nodesBackTopEdge // ColS nodesLeftBottomEdge(); // alias, see above: nodesBottomLeftEdge // ColS nodesLeftFrontEdge(); // alias, see above: nodesFrontLeftEdge // ColS nodesLeftBackEdge(); // alias, see above: nodesBackLeftEdge // ColS nodesLeftTopEdge(); // alias, see above: nodesTopLeftEdge // ColS nodesRightBottomEdge(); // alias, see above: nodesBottomRightEdge // ColS nodesRightTopEdge(); // alias, see above: nodesTopRightEdge // ColS nodesRightFrontEdge(); // alias, see above: nodesFrontRightEdge // ColS nodesRightBackEdge(); // alias, see above: nodesBackRightEdge - // // boundary nodes: corners - // size_t nodesFrontBottomLeftCorner(); // node-number of the front - bottom - left corner - // size_t nodesFrontBottomRightCorner(); // node-number of the front - bottom - right corner - // size_t nodesFrontTopLeftCorner(); // node-number of the front - top - left corner - // size_t nodesFrontTopRightCorner(); // node-number of the front - top - right corner - // size_t nodesBackBottomLeftCorner(); // node-number of the back - bottom - left corner - // size_t nodesBackBottomRightCorner(); // node-number of the back - bottom - right corner - // size_t nodesBackTopLeftCorner(); // node-number of the back - top - left corner - // size_t nodesBackTopRightCorner(); // node-number of the back - top - right corner + // boundary nodes: corners + size_t nodesFrontBottomLeftCorner(); // node-number of the front - bottom - left corner + size_t nodesFrontBottomRightCorner(); // node-number of the front - bottom - right corner + size_t nodesFrontTopLeftCorner(); // node-number of the front - top - left corner + size_t nodesFrontTopRightCorner(); // node-number of the front - top - right corner + size_t nodesBackBottomLeftCorner(); // node-number of the back - bottom - left corner + size_t nodesBackBottomRightCorner(); // node-number of the back - bottom - right corner + size_t nodesBackTopLeftCorner(); // node-number of the back - top - left corner + size_t nodesBackTopRightCorner(); // node-number of the back - top - right corner // // boundary nodes: corners (aliases) // size_t nodesFrontLeftBottomCorner(); // alias, see above: nodesFrontBottomLeftCorner // size_t nodesBottomFrontLeftCorner(); // alias, see above: nodesFrontBottomLeftCorner // size_t nodesBottomLeftFrontCorner(); // alias, see above: nodesFrontBottomLeftCorner // size_t nodesLeftFrontBottomCorner(); // alias, see above: nodesFrontBottomLeftCorner // size_t nodesLeftBottomFrontCorner(); // alias, see above: nodesFrontBottomLeftCorner // size_t nodesFrontRightBottomCorner(); // alias, see above: nodesFrontBottomRightCorner // size_t nodesBottomFrontRightCorner(); // alias, see above: nodesFrontBottomRightCorner // size_t nodesBottomRightFrontCorner(); // alias, see above: nodesFrontBottomRightCorner // size_t nodesRightFrontBottomCorner(); // alias, see above: nodesFrontBottomRightCorner // size_t nodesRightBottomFrontCorner(); // alias, see above: nodesFrontBottomRightCorner // size_t nodesFrontLeftTopCorner(); // alias, see above: nodesFrontTopLeftCorner // size_t nodesTopFrontLeftCorner(); // alias, see above: nodesFrontTopLeftCorner // size_t nodesTopLeftFrontCorner(); // alias, see above: nodesFrontTopLeftCorner // size_t nodesLeftFrontTopCorner(); // alias, see above: nodesFrontTopLeftCorner // size_t nodesLeftTopFrontCorner(); // alias, see above: nodesFrontTopLeftCorner // size_t nodesFrontRightTopCorner(); // alias, see above: nodesFrontTopRightCorner // size_t nodesTopFrontRightCorner(); // alias, see above: nodesFrontTopRightCorner // size_t nodesTopRightFrontCorner(); // alias, see above: nodesFrontTopRightCorner // size_t nodesRightFrontTopCorner(); // alias, see above: nodesFrontTopRightCorner // size_t nodesRightTopFrontCorner(); // alias, see above: nodesFrontTopRightCorner // size_t nodesBackLeftBottomCorner(); // alias, see above: nodesBackBottomLeftCorner // size_t nodesBottomBackLeftCorner(); // alias, see above: nodesBackBottomLeftCorner // size_t nodesBottomLeftBackCorner(); // alias, see above: nodesBackBottomLeftCorner // size_t nodesLeftBackBottomCorner(); // alias, see above: nodesBackBottomLeftCorner // size_t nodesLeftBottomBackCorner(); // alias, see above: nodesBackBottomLeftCorner // size_t nodesBackRightBottomCorner(); // alias, see above: nodesBackBottomRightCorner // size_t nodesBottomBackRightCorner(); // alias, see above: nodesBackBottomRightCorner // size_t nodesBottomRightBackCorner(); // alias, see above: nodesBackBottomRightCorner // size_t nodesRightBackBottomCorner(); // alias, see above: nodesBackBottomRightCorner // size_t nodesRightBottomBackCorner(); // alias, see above: nodesBackBottomRightCorner // size_t nodesBackLeftTopCorner(); // alias, see above: nodesBackTopLeftCorner // size_t nodesTopBackLeftCorner(); // alias, see above: nodesBackTopLeftCorner // size_t nodesTopLeftBackCorner(); // alias, see above: nodesBackTopLeftCorner // size_t nodesLeftBackTopCorner(); // alias, see above: nodesBackTopLeftCorner // size_t nodesLeftTopBackCorner(); // alias, see above: nodesBackTopLeftCorner // size_t nodesBackRightTopCorner(); // alias, see above: nodesBackTopRightCorner // size_t nodesTopBackRightCorner(); // alias, see above: nodesBackTopRightCorner // size_t nodesTopRightBackCorner(); // alias, see above: nodesBackTopRightCorner // size_t nodesRightBackTopCorner(); // alias, see above: nodesBackTopRightCorner // size_t nodesRightTopBackCorner(); // alias, see above: nodesBackTopRightCorner // // periodicity // MatS nodesPeriodic(); // periodic node pairs [:,2]: (independent, dependent) // size_t nodesOrigin(); // front-bottom-left node, used as reference for periodicity // MatS dofs(); // DOF-numbers for each component of each node (sequential) // MatS dofsPeriodic(); // ,, for the case that the periodicity if fully eliminated }; // ================================================================================================= }}} // namespace ... // ================================================================================================= #endif