Merge pull request #45 from solvcon/project/ustmesh

Add the minimal code for unstructured mesh

Author: yungyuc

.clang-tidy

@@ -13,6 +13,7 @@ Checks: >
     hicpp-avoid-goto,hicpp-exception-baseclass,hicpp-multiway-paths-covered,
     hicpp-no-assembler,hicpp-signed-bitwise,
     -cppcoreguidelines-pro-bounds-array-to-pointer-decay,
+    -cppcoreguidelines-pro-bounds-constant-array-index,
     -cppcoreguidelines-pro-bounds-pointer-arithmetic,
     -google-readability-todo,
     -google-runtime-references,
@@ -22,6 +23,7 @@ Checks: >
     -performance-noexcept-move-constructor,
     -readability-named-parameter,
     -readability-magic-numbers,
+    -readability-redundant-access-specifiers,
     -misc-non-private-member-variables-in-classes
 WarningsAsErrors: ''
 HeaderFilterRegex: 'modmesh.*'

CMakeLists.txt

@@ -73,6 +73,10 @@ set(MODMESH_HEADERS
     include/modmesh/base.hpp
     include/modmesh/profile.hpp
     include/modmesh/grid.hpp
+    include/modmesh/mesh.hpp
+    include/modmesh/mesh/StaticMesh_decl.hpp
+    include/modmesh/mesh/boundary.hpp
+    include/modmesh/mesh/interior.hpp
     include/modmesh/small_vector.hpp
     include/modmesh/ConcreteBuffer.hpp
     include/modmesh/SimpleArray.hpp

include/modmesh/ConcreteBuffer.hpp

@@ -32,6 +32,8 @@
 
 #include <stdexcept>
 #include <memory>
+#include <algorithm>
+#include <sstream>
 
 namespace modmesh
 {

include/modmesh/SimpleArray.hpp

@@ -119,15 +119,29 @@ class SimpleArray
         }
     }
 
+    // NOLINTNEXTLINE(modernize-pass-by-value)
+    explicit SimpleArray(small_vector<size_t> const & shape, value_type const & value)
+      : SimpleArray(shape)
+    {
+        std::fill(begin(), end(), value);
+    }
+
     explicit SimpleArray(std::vector<size_t> const & shape)
       : m_shape(shape), m_stride(calc_stride(m_shape))
     {
-        if (!m_shape.empty()) {
+        if (!m_shape.empty())
+        {
             m_buffer = buffer_type::construct(m_shape[0] * m_stride[0] * ITEMSIZE);
             m_body = m_buffer->data<T>();
         }
     }
 
+    explicit SimpleArray(std::vector<size_t> const & shape, value_type const & value)
+      : SimpleArray(shape)
+    {
+        std::fill(begin(), end(), value);
+    }
+
     explicit SimpleArray(std::shared_ptr<buffer_type> const & buffer)
     {
         if (buffer)
@@ -169,20 +183,6 @@ class SimpleArray
         }
     }
 
-    static shape_type calc_stride(shape_type const & shape)
-    {
-        shape_type stride(shape.size());
-        if (!shape.empty())
-        {
-            stride[shape.size()-1] = 1;
-            for (size_t it=shape.size()-1; it>0; --it)
-            {
-                stride[it-1] = stride[it] * shape[it];
-            }
-        }
-        return stride;
-    }
-
     SimpleArray(std::initializer_list<T> init)
       : SimpleArray(init.size())
     {
@@ -199,21 +199,6 @@ class SimpleArray
       , m_body(calc_body(m_buffer->data<T>(), m_stride, other.m_nghost))
     {}
 
-    static T * calc_body(T * data, shape_type const & stride, size_t nghost)
-    {
-        if (nullptr == data || stride.empty() || 0 == nghost)
-        {
-            // Do nothing.
-        }
-        else
-        {
-            shape_type shape(stride.size(), 0);
-            shape[0] = nghost;
-            data += buffer_offset(stride, shape);
-        }
-        return data;
-    }
-
     SimpleArray(SimpleArray && other) noexcept
       : m_buffer(std::move(other.m_buffer))
       , m_shape(std::move(other.m_shape))
@@ -248,6 +233,42 @@ class SimpleArray
 
     ~SimpleArray() = default;
 
+    template < typename ... Args >
+    SimpleArray & remake(Args && ... args)
+    {
+        SimpleArray(args ...).swap(*this);
+        return *this;
+    }
+
+    static shape_type calc_stride(shape_type const & shape)
+    {
+        shape_type stride(shape.size());
+        if (!shape.empty())
+        {
+            stride[shape.size()-1] = 1;
+            for (size_t it=shape.size()-1; it>0; --it)
+            {
+                stride[it-1] = stride[it] * shape[it];
+            }
+        }
+        return stride;
+    }
+
+    static T * calc_body(T * data, shape_type const & stride, size_t nghost)
+    {
+        if (nullptr == data || stride.empty() || 0 == nghost)
+        {
+            // Do nothing.
+        }
+        else
+        {
+            shape_type shape(stride.size(), 0);
+            shape[0] = nghost;
+            data += buffer_offset(stride, shape);
+        }
+        return data;
+    }
+
     explicit operator bool() const noexcept { return bool(m_buffer) && bool(*m_buffer); }
 
     size_t nbytes() const noexcept { return m_buffer ? m_buffer->nbytes() : 0; }
@@ -359,7 +380,7 @@ class SimpleArray
         return SimpleArray(m_shape, m_buffer);
     }
 
-    void swap(SimpleArray<T> && other)
+    void swap(SimpleArray & other) noexcept
     {
         if (this != &other)
         {
@@ -372,10 +393,14 @@ class SimpleArray
     }
 
     template < typename ... Args >
-    value_type const & operator()(Args ... args) const { return m_body[buffer_offset(m_stride, args...)]; }
+    value_type const & operator()(Args ... args) const { return *vptr(args...); }
+    template < typename ... Args >
+    value_type       & operator()(Args ... args)       { return *vptr(args...); }
 
     template < typename ... Args >
-    value_type       & operator()(Args ... args)       { return m_body[buffer_offset(m_stride, args...)]; }
+    value_type const * vptr(Args ... args) const { return m_body + buffer_offset(m_stride, args...); }
+    template < typename ... Args >
+    value_type       * vptr(Args ... args)       { return m_body + buffer_offset(m_stride, args...); }
 
     /* Backdoor */
     value_type const & data(size_t it) const { return data()[it]; }

include/modmesh/base.hpp

@@ -43,22 +43,40 @@
 namespace modmesh
 {
 
+template <typename I, typename R>
+class NumberBase
+{
+
+public:
+
+    using int_type = I;
+    using uint_type = std::make_unsigned_t<I>;
+    using size_type = uint_type;
+    using real_type = R;
+
+}; /* end class NumberBase */
+
 /**
  * Spatial table basic information.  Any table-based data store for spatial
  * data should inherit this class template.
  */
-template <size_t ND>
+template <uint8_t ND, typename I, typename R>
 class SpaceBase
+  : public NumberBase<I, R>
 {
 
 public:
 
-    static constexpr const size_t NDIM = ND;
+    using dim_type = uint8_t;
+    static constexpr const dim_type NDIM = ND;
+
+    using number_base = NumberBase<I, R>;
 
-    using int_type = int32_t;
-    using uint_type = uint32_t;
-    using serial_type = uint_type;
-    using real_type = double;
+    using int_type = typename number_base::int_type;
+    using uint_type = typename number_base::uint_type;
+    using size_type = typename number_base::size_type;
+    using serial_type = typename number_base::size_type;
+    using real_type = typename number_base::real_type;
 
 }; /* end class SpaceBase */
 

include/modmesh/grid.hpp

@@ -42,9 +42,9 @@ namespace modmesh
 /**
  * Base class template for structured grid.
  */
-template <size_t ND>
+template <uint8_t ND>
 class StaticGridBase
-  : public SpaceBase<ND>
+  : public SpaceBase<ND, int32_t, double>
 {
 }; /* end class StaticGridBase */
 

include/modmesh/mesh.hpp

@@ -0,0 +1,39 @@
+#pragma once
+
+/*
+ * Copyright (c) 2021, Yung-Yu Chen <[email protected]>
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright notice,
+ *   this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright notice,
+ *   this list of conditions and the following disclaimer in the documentation
+ *   and/or other materials provided with the distribution.
+ * - Neither the name of the copyright holder nor the names of its contributors
+ *   may be used to endorse or promote products derived from this software
+ *   without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/**
+ * Unstructured mesh.
+ */
+
+#include <modmesh/mesh/StaticMesh_decl.hpp>
+#include <modmesh/mesh/boundary.hpp>
+#include <modmesh/mesh/interior.hpp>
+
+// vim: set ff=unix fenc=utf8 et sw=4 ts=4 sts=4: