Add regular Cartesian mesh generation

The mesh is defined by two opposite corners and the number of cells in
each direction.

CMakeLists.txt

@@ -397,6 +397,7 @@ target_link_libraries(
   PugsLanguage
   PugsLanguageAST
   PugsLanguageModules
+  PugsMesh
   PugsLanguageUtils
   kokkos
   ${PARMETIS_LIBRARIES}

src/language/modules/MeshModule.cpp

 #include <language/modules/MeshModule.hpp>
 
+#include <algebra/TinyVector.hpp>
 #include <language/node_processor/ExecutionPolicy.hpp>
 #include <language/utils/BuiltinFunctionEmbedder.hpp>
 #include <language/utils/FunctionTable.hpp>
 #include <language/utils/PugsFunctionAdapter.hpp>
 #include <language/utils/SymbolTable.hpp>
 #include <language/utils/TypeDescriptor.hpp>
+#include <mesh/CartesianMeshBuilder.hpp>
 #include <mesh/Connectivity.hpp>
 #include <mesh/GmshReader.hpp>
 #include <mesh/Mesh.hpp>
@@ -104,6 +106,66 @@ MeshModule::MeshModule()
 
                             ));
 
+  this->_addBuiltinFunction("cartesian1dMesh",
+                            std::make_shared<BuiltinFunctionEmbedder<std::shared_ptr<const IMesh>, TinyVector<1>,
+                                                                     TinyVector<1>, std::vector<uint64_t>>>(
+
+                              std::function<std::shared_ptr<const IMesh>(TinyVector<1>, TinyVector<1>,
+                                                                         std::vector<uint64_t>)>{
+
+                                [&](const TinyVector<1> a, const TinyVector<1> b,
+                                    const std::vector<uint64_t>& box_sizes) -> std::shared_ptr<const IMesh> {
+                                  constexpr uint64_t dimension = 1;
+
+                                  if (box_sizes.size() != dimension) {
+                                    throw NormalError("expecting " + std::to_string(dimension) +
+                                                      " dimensions, provided " + std::to_string(box_sizes.size()));
+                                  }
+
+                                  const TinyVector<dimension, uint64_t> sizes = [&]() {
+                                    TinyVector<dimension, uint64_t> s;
+                                    for (size_t i = 0; i < dimension; ++i) {
+                                      s[i] = box_sizes[i];
+                                    }
+                                    return s;
+                                  }();
+
+                                  CartesianMeshBuilder builder{a, b, sizes};
+                                  return builder.mesh();
+                                }}
+
+                              ));
+
+  this->_addBuiltinFunction("cartesian2dMesh",
+                            std::make_shared<BuiltinFunctionEmbedder<std::shared_ptr<const IMesh>, TinyVector<2>,
+                                                                     TinyVector<2>, std::vector<uint64_t>>>(
+
+                              std::function<std::shared_ptr<const IMesh>(TinyVector<2>, TinyVector<2>,
+                                                                         std::vector<uint64_t>)>{
+
+                                [&](const TinyVector<2> a, const TinyVector<2> b,
+                                    const std::vector<uint64_t>& box_sizes) -> std::shared_ptr<const IMesh> {
+                                  constexpr uint64_t dimension = 2;
+
+                                  if (box_sizes.size() != dimension) {
+                                    throw NormalError("expecting " + std::to_string(dimension) +
+                                                      " dimensions, provided " + std::to_string(box_sizes.size()));
+                                  }
+
+                                  const TinyVector<dimension, uint64_t> sizes = [&]() {
+                                    TinyVector<dimension, uint64_t> s;
+                                    for (size_t i = 0; i < dimension; ++i) {
+                                      s[i] = box_sizes[i];
+                                    }
+                                    return s;
+                                  }();
+
+                                  CartesianMeshBuilder builder{a, b, sizes};
+                                  return builder.mesh();
+                                }}
+
+                              ));
+
   this->_addBuiltinFunction("cartesian3dMesh",
                             std::make_shared<BuiltinFunctionEmbedder<std::shared_ptr<const IMesh>, TinyVector<3>,
                                                                      TinyVector<3>, std::vector<uint64_t>>>(
@@ -111,14 +173,25 @@ MeshModule::MeshModule()
                               std::function<std::shared_ptr<const IMesh>(TinyVector<3>, TinyVector<3>,
                                                                          std::vector<uint64_t>)>{
 
-                                [](const TinyVector<3>& a, const TinyVector<3>& b,
+                                [&](const TinyVector<3>& a, const TinyVector<3>& b,
                                     const std::vector<uint64_t>& box_sizes) -> std::shared_ptr<const IMesh> {
-                                  std::cout << a << " -> " << b << " ";
-                                  for (auto i : box_sizes) {
-                                    std::cout << i << ' ';
+                                  constexpr uint64_t dimension = 3;
+
+                                  if (box_sizes.size() != dimension) {
+                                    throw NormalError("expecting " + std::to_string(dimension) +
+                                                      " dimensions, provided " + std::to_string(box_sizes.size()));
                                   }
-                                  std::cout << '\n';
-                                  return nullptr;
+
+                                  const TinyVector<dimension, uint64_t> sizes = [&]() {
+                                    TinyVector<dimension, uint64_t> s;
+                                    for (size_t i = 0; i < dimension; ++i) {
+                                      s[i] = box_sizes[i];
+                                    }
+                                    return s;
+                                  }();
+
+                                  CartesianMeshBuilder builder{a, b, sizes};
+                                  return builder.mesh();
                                 }}
 
                               ));

src/mesh/CMakeLists.txt

@@ -2,6 +2,7 @@
 
 add_library(
   PugsMesh
+  CartesianMeshBuilder.cpp
   Connectivity.cpp
   ConnectivityComputer.cpp
   ConnectivityDispatcher.cpp

src/mesh/CartesianMeshBuilder.hpp

+#ifndef CARTESIAN_MESH_BUILDER_HPP
+#define CARTESIAN_MESH_BUILDER_HPP
+
+#include <algebra/TinyVector.hpp>
+#include <mesh/Mesh.hpp>
+#include <mesh/MeshBuilderBase.hpp>
+
+#include <memory>
+
+class CartesianMeshBuilder : public MeshBuilderBase
+{
+ private:
+  template <size_t Dimension>
+  void _buildBoundaryNodeList(const TinyVector<Dimension, uint64_t>& cell_size, ConnectivityDescriptor& descriptor);
+
+  template <size_t Dimension>
+  void _buildBoundaryFaceList(const TinyVector<Dimension, uint64_t>& cell_size, ConnectivityDescriptor& descriptor);
+
+  template <size_t Dimension>
+  void _buildCartesianMesh(const TinyVector<Dimension>& a,
+                           const TinyVector<Dimension>& b,
+                           const TinyVector<Dimension, uint64_t>& size);
+
+ public:
+  template <size_t Dimension>
+  CartesianMeshBuilder(const TinyVector<Dimension>& a,
+                       const TinyVector<Dimension>& b,
+                       const TinyVector<Dimension, uint64_t>& size);
+  ~CartesianMeshBuilder() = default;
+};
+
+#endif   // CARTESIAN_MESH_BUILDER_HPP