Add wall and inflow list boundary condition descriptors

This is a raw copy from `feature/composite-scheme`

Also plug to checkpointing and add related tests

src/language/modules/SchemeModule.cpp

@@ -42,10 +42,12 @@
 #include <scheme/IBoundaryConditionDescriptor.hpp>
 #include <scheme/IDiscreteFunctionDescriptor.hpp>
 #include <scheme/InflowBoundaryConditionDescriptor.hpp>
+#include <scheme/InflowListBoundaryConditionDescriptor.hpp>
 #include <scheme/NeumannBoundaryConditionDescriptor.hpp>
 #include <scheme/OutflowBoundaryConditionDescriptor.hpp>
 #include <scheme/SymmetryBoundaryConditionDescriptor.hpp>
 #include <scheme/VariableBCDescriptor.hpp>
+#include <scheme/WallBoundaryConditionDescriptor.hpp>
 #include <utils/Socket.hpp>
 
 #include <utils/checkpointing/ReadDiscreteFunctionVariant.hpp>
@@ -348,6 +350,15 @@ SchemeModule::SchemeModule()
 
                                           ));
 
+  this->_addBuiltinFunction("wall", std::function(
+
+                                      [](std::shared_ptr<const IBoundaryDescriptor> boundary)
+                                        -> std::shared_ptr<const IBoundaryConditionDescriptor> {
+                                        return std::make_shared<WallBoundaryConditionDescriptor>(boundary);
+                                      }
+
+                                      ));
+
   this->_addBuiltinFunction("pressure", std::function(
 
                                           [](std::shared_ptr<const IBoundaryDescriptor> boundary,
@@ -407,6 +418,18 @@ SchemeModule::SchemeModule()
 
                                         ));
 
+  this->_addBuiltinFunction("inflow_list",
+                            std::function(
+
+                              [](std::shared_ptr<const IBoundaryDescriptor> boundary,
+                                 const std::vector<FunctionSymbolId>& function_id_list)
+                                -> std::shared_ptr<const IBoundaryConditionDescriptor> {
+                                return std::make_shared<InflowListBoundaryConditionDescriptor>(boundary,
+                                                                                               function_id_list);
+                              }
+
+                              ));
+
   this->_addBuiltinFunction("outflow", std::function(
 
                                          [](std::shared_ptr<const IBoundaryDescriptor> boundary)

src/scheme/IBoundaryConditionDescriptor.hpp

@@ -18,9 +18,11 @@ class IBoundaryConditionDescriptor
     fixed,
     free,
     inflow,
+    inflow_list,
     neumann,
     outflow,
-    symmetry
+    symmetry,
+    wall
   };
 
  protected:

src/scheme/InflowListBoundaryConditionDescriptor.hpp

+#ifndef INFLOW_LIST_BOUNDARY_CONDITION_DESCRIPTOR_HPP
+#define INFLOW_LIST_BOUNDARY_CONDITION_DESCRIPTOR_HPP
+
+#include <language/utils/FunctionSymbolId.hpp>
+#include <mesh/IBoundaryDescriptor.hpp>
+#include <scheme/BoundaryConditionDescriptorBase.hpp>
+
+#include <memory>
+
+class InflowListBoundaryConditionDescriptor : public BoundaryConditionDescriptorBase
+{
+ private:
+  std::ostream&
+  _write(std::ostream& os) const final
+  {
+    os << "inflow_list(" << ',' << *m_boundary_descriptor << ")";
+    return os;
+  }
+
+  const std::vector<FunctionSymbolId> m_function_symbol_id_list;
+
+ public:
+  const std::vector<FunctionSymbolId>&
+  functionSymbolIdList() const
+  {
+    return m_function_symbol_id_list;
+  }
+
+  Type
+  type() const final
+  {
+    return Type::inflow_list;
+  }
+
+  InflowListBoundaryConditionDescriptor(std::shared_ptr<const IBoundaryDescriptor> boundary_descriptor,
+                                        const std::vector<FunctionSymbolId>& function_symbol_id_list)
+    : BoundaryConditionDescriptorBase{boundary_descriptor}, m_function_symbol_id_list{function_symbol_id_list}
+  {
+    ;
+  }
+
+  InflowListBoundaryConditionDescriptor(const InflowListBoundaryConditionDescriptor&) = delete;
+  InflowListBoundaryConditionDescriptor(InflowListBoundaryConditionDescriptor&&)      = delete;
+
+  ~InflowListBoundaryConditionDescriptor() = default;
+};
+
+#endif   // INFLOW_LIST_BOUNDARY_CONDITION_DESCRIPTOR_HPP

src/scheme/WallBoundaryConditionDescriptor.hpp

+#ifndef WALL_BOUNDARY_CONDITION_DESCRIPTOR_HPP
+#define WALL_BOUNDARY_CONDITION_DESCRIPTOR_HPP
+
+#include <language/utils/FunctionSymbolId.hpp>
+#include <mesh/IBoundaryDescriptor.hpp>
+#include <scheme/BoundaryConditionDescriptorBase.hpp>
+
+#include <memory>
+
+class WallBoundaryConditionDescriptor : public BoundaryConditionDescriptorBase
+{
+ private:
+  std::ostream&
+  _write(std::ostream& os) const final
+  {
+    os << "wall(" << *m_boundary_descriptor << ")";
+    return os;
+  }
+
+ public:
+  Type
+  type() const final
+  {
+    return Type::wall;
+  }
+
+  WallBoundaryConditionDescriptor(const std::shared_ptr<const IBoundaryDescriptor>& boundary_descriptor)
+
+    : BoundaryConditionDescriptorBase{boundary_descriptor}
+  {
+    ;
+  }
+
+  WallBoundaryConditionDescriptor(const WallBoundaryConditionDescriptor&) = delete;
+  WallBoundaryConditionDescriptor(WallBoundaryConditionDescriptor&&)      = delete;
+
+  ~WallBoundaryConditionDescriptor() = default;
+};
+
+#endif   // WALL_BOUNDARY_CONDITION_DESCRIPTOR_HPP

src/utils/checkpointing/IBoundaryConditionDescriptorHFType.hpp

@@ -15,9 +15,11 @@ create_enum_i_boundary_condition_descriptor_type()
           {"fourier", IBoundaryConditionDescriptor::Type::fourier},
           {"free", IBoundaryConditionDescriptor::Type::free},
           {"inflow", IBoundaryConditionDescriptor::Type::inflow},
+          {"inflow_list", IBoundaryConditionDescriptor::Type::inflow_list},
           {"neumann", IBoundaryConditionDescriptor::Type::neumann},
           {"outflow", IBoundaryConditionDescriptor::Type::outflow},
-          {"symmetry", IBoundaryConditionDescriptor::Type::symmetry}};
+          {"symmetry", IBoundaryConditionDescriptor::Type::symmetry},
+          {"wall", IBoundaryConditionDescriptor::Type::wall}};
 }
 HIGHFIVE_REGISTER_TYPE(IBoundaryConditionDescriptor::Type, create_enum_i_boundary_condition_descriptor_type)
 

src/utils/checkpointing/ReadIBoundaryConditionDescriptor.cpp

@@ -10,9 +10,11 @@
 #include <scheme/FourierBoundaryConditionDescriptor.hpp>
 #include <scheme/FreeBoundaryConditionDescriptor.hpp>
 #include <scheme/InflowBoundaryConditionDescriptor.hpp>
+#include <scheme/InflowListBoundaryConditionDescriptor.hpp>
 #include <scheme/NeumannBoundaryConditionDescriptor.hpp>
 #include <scheme/OutflowBoundaryConditionDescriptor.hpp>
 #include <scheme/SymmetryBoundaryConditionDescriptor.hpp>
+#include <scheme/WallBoundaryConditionDescriptor.hpp>
 #include <utils/Exceptions.hpp>
 #include <utils/checkpointing/IBoundaryConditionDescriptorHFType.hpp>
 #include <utils/checkpointing/ReadIBoundaryDescriptor.hpp>
@@ -82,6 +84,19 @@ readIBoundaryConditionDescriptor(const HighFive::Group& iboundaryconditiondecrip
                                                                   function_id));
     break;
   }
+  case IBoundaryConditionDescriptor::Type::inflow_list: {
+    const std::vector function_id_list =
+      iboundaryconditiondecriptor_group.getAttribute("function_id_list").read<std::vector<size_t>>();
+
+    std::vector<FunctionSymbolId> function_symbol_id_list;
+    for (auto function_id : function_id_list) {
+      function_symbol_id_list.push_back(*ResumingData::instance().functionSymbolId(function_id));
+    }
+
+    bc_descriptor =
+      std::make_shared<const InflowListBoundaryConditionDescriptor>(i_boundary_descriptor, function_symbol_id_list);
+    break;
+  }
   case IBoundaryConditionDescriptor::Type::neumann: {
     const std::string name = iboundaryconditiondecriptor_group.getAttribute("name").read<std::string>();
     const size_t rhs_id    = iboundaryconditiondecriptor_group.getAttribute("rhs_function_id").read<size_t>();
@@ -99,6 +114,10 @@ readIBoundaryConditionDescriptor(const HighFive::Group& iboundaryconditiondecrip
     bc_descriptor = std::make_shared<const SymmetryBoundaryConditionDescriptor>(i_boundary_descriptor);
     break;
   }
+  case IBoundaryConditionDescriptor::Type::wall: {
+    bc_descriptor = std::make_shared<const WallBoundaryConditionDescriptor>(i_boundary_descriptor);
+    break;
+  }
   }
 
   return bc_descriptor;

src/utils/checkpointing/WriteIBoundaryConditionDescriptor.cpp

@@ -9,9 +9,11 @@
 #include <scheme/FourierBoundaryConditionDescriptor.hpp>
 #include <scheme/FreeBoundaryConditionDescriptor.hpp>
 #include <scheme/InflowBoundaryConditionDescriptor.hpp>
+#include <scheme/InflowListBoundaryConditionDescriptor.hpp>
 #include <scheme/NeumannBoundaryConditionDescriptor.hpp>
 #include <scheme/OutflowBoundaryConditionDescriptor.hpp>
 #include <scheme/SymmetryBoundaryConditionDescriptor.hpp>
+#include <scheme/WallBoundaryConditionDescriptor.hpp>
 #include <utils/Exceptions.hpp>
 #include <utils/checkpointing/IBoundaryConditionDescriptorHFType.hpp>
 #include <utils/checkpointing/WriteIBoundaryDescriptor.hpp>
@@ -81,6 +83,17 @@ writeIBoundaryConditionDescriptor(HighFive::Group& variable_group,
     variable_group.createAttribute("function_id", inflow_bc_descriptor.functionSymbolId().id());
     break;
   }
+  case IBoundaryConditionDescriptor::Type::inflow_list: {
+    const InflowListBoundaryConditionDescriptor& inflow_list_bc_descriptor =
+      dynamic_cast<const InflowListBoundaryConditionDescriptor&>(iboundary_condition_descriptor);
+    writeIBoundaryDescriptor(boundary_group, inflow_list_bc_descriptor.boundaryDescriptor());
+    std::vector<size_t> function_id_list;
+    for (auto&& function_symbol_id : inflow_list_bc_descriptor.functionSymbolIdList()) {
+      function_id_list.push_back(function_symbol_id.id());
+    }
+    variable_group.createAttribute("function_id_list", function_id_list);
+    break;
+  }
   case IBoundaryConditionDescriptor::Type::neumann: {
     const NeumannBoundaryConditionDescriptor& neumann_bc_descriptor =
       dynamic_cast<const NeumannBoundaryConditionDescriptor&>(iboundary_condition_descriptor);
@@ -101,6 +114,12 @@ writeIBoundaryConditionDescriptor(HighFive::Group& variable_group,
     writeIBoundaryDescriptor(boundary_group, symmetric_bc_descriptor.boundaryDescriptor());
     break;
   }
+  case IBoundaryConditionDescriptor::Type::wall: {
+    const WallBoundaryConditionDescriptor& wall_bc_descriptor =
+      dynamic_cast<const WallBoundaryConditionDescriptor&>(iboundary_condition_descriptor);
+    writeIBoundaryDescriptor(boundary_group, wall_bc_descriptor.boundaryDescriptor());
+    break;
+  }
   }
 }
 

tests/test_checkpointing_IBoundaryConditionDescriptor.cpp

@@ -14,9 +14,11 @@
 #include <scheme/FourierBoundaryConditionDescriptor.hpp>
 #include <scheme/FreeBoundaryConditionDescriptor.hpp>
 #include <scheme/InflowBoundaryConditionDescriptor.hpp>
+#include <scheme/InflowListBoundaryConditionDescriptor.hpp>
 #include <scheme/NeumannBoundaryConditionDescriptor.hpp>
 #include <scheme/OutflowBoundaryConditionDescriptor.hpp>
 #include <scheme/SymmetryBoundaryConditionDescriptor.hpp>
+#include <scheme/WallBoundaryConditionDescriptor.hpp>
 #include <utils/checkpointing/ReadIBoundaryConditionDescriptor.hpp>
 #include <utils/checkpointing/ResumingData.hpp>
 #include <utils/checkpointing/WriteIBoundaryConditionDescriptor.hpp>
@@ -139,6 +141,13 @@ let i: R -> R, x -> x+3;
                                                          p_sym_bc_descriptor)},
                                                        file, useless_group, symbol_table_group);
 
+      auto p_wall_bc_descriptor = std::make_shared<const WallBoundaryConditionDescriptor>(p_boundary_1);
+      checkpointing::writeIBoundaryConditionDescriptor("wall_bc_descriptor",
+                                                       EmbeddedData{std::make_shared<
+                                                         DataHandler<const IBoundaryConditionDescriptor>>(
+                                                         p_wall_bc_descriptor)},
+                                                       file, useless_group, symbol_table_group);
+
       auto p_outflow_bc_descriptor = std::make_shared<const OutflowBoundaryConditionDescriptor>(p_boundary_2);
       checkpointing::writeIBoundaryConditionDescriptor("outflow_bc_descriptor",
                                                        EmbeddedData{std::make_shared<
@@ -199,6 +208,16 @@ let i: R -> R, x -> x+3;
                                                          p_inflow_bc_descriptor)},
                                                        file, useless_group, symbol_table_group);
 
+      const std::vector<FunctionSymbolId> inflow_list_function_id_list{FunctionSymbolId{2, symbol_table},
+                                                                       FunctionSymbolId{3, symbol_table}};
+      auto p_inflow_list_bc_descriptor =
+        std::make_shared<const InflowListBoundaryConditionDescriptor>(p_boundary_1, inflow_list_function_id_list);
+      checkpointing::writeIBoundaryConditionDescriptor("inflow_list_bc_descriptor",
+                                                       EmbeddedData{std::make_shared<
+                                                         DataHandler<const IBoundaryConditionDescriptor>>(
+                                                         p_inflow_list_bc_descriptor)},
+                                                       file, useless_group, symbol_table_group);
+
       file.flush();
 
       checkpointing::ResumingData::create();
@@ -211,6 +230,9 @@ let i: R -> R, x -> x+3;
       EmbeddedData read_sym_bc_descriptor =
         checkpointing::readIBoundaryConditionDescriptor("sym_bc_descriptor", symbol_table_group);
 
+      EmbeddedData read_wall_bc_descriptor =
+        checkpointing::readIBoundaryConditionDescriptor("wall_bc_descriptor", symbol_table_group);
+
       EmbeddedData read_outflow_bc_descriptor =
         checkpointing::readIBoundaryConditionDescriptor("outflow_bc_descriptor", symbol_table_group);
 
@@ -232,12 +254,16 @@ let i: R -> R, x -> x+3;
       EmbeddedData read_inflow_bc_descriptor =
         checkpointing::readIBoundaryConditionDescriptor("inflow_bc_descriptor", symbol_table_group);
 
+      EmbeddedData read_inflow_list_bc_descriptor =
+        checkpointing::readIBoundaryConditionDescriptor("inflow_list_bc_descriptor", symbol_table_group);
+
       auto get_value = [](const EmbeddedData& embedded_data) -> const IBoundaryConditionDescriptor& {
         return *dynamic_cast<const DataHandler<const IBoundaryConditionDescriptor>&>(embedded_data.get()).data_ptr();
       };
 
       REQUIRE_NOTHROW(get_value(read_axis_bc_descriptor));
       REQUIRE_NOTHROW(get_value(read_sym_bc_descriptor));
+      REQUIRE_NOTHROW(get_value(read_wall_bc_descriptor));
       REQUIRE_NOTHROW(get_value(read_outflow_bc_descriptor));
       REQUIRE_NOTHROW(get_value(read_free_bc_descriptor));
       REQUIRE_NOTHROW(get_value(read_fixed_bc_descriptor));
@@ -245,9 +271,11 @@ let i: R -> R, x -> x+3;
       REQUIRE_NOTHROW(get_value(read_neumann_bc_descriptor));
       REQUIRE_NOTHROW(get_value(read_fourier_bc_descriptor));
       REQUIRE_NOTHROW(get_value(read_inflow_bc_descriptor));
+      REQUIRE_NOTHROW(get_value(read_inflow_list_bc_descriptor));
 
       REQUIRE(get_value(read_axis_bc_descriptor).type() == IBoundaryConditionDescriptor::Type::axis);
       REQUIRE(get_value(read_sym_bc_descriptor).type() == IBoundaryConditionDescriptor::Type::symmetry);
+      REQUIRE(get_value(read_wall_bc_descriptor).type() == IBoundaryConditionDescriptor::Type::wall);
       REQUIRE(get_value(read_outflow_bc_descriptor).type() == IBoundaryConditionDescriptor::Type::outflow);
       REQUIRE(get_value(read_free_bc_descriptor).type() == IBoundaryConditionDescriptor::Type::free);
       REQUIRE(get_value(read_fixed_bc_descriptor).type() == IBoundaryConditionDescriptor::Type::fixed);
@@ -255,9 +283,11 @@ let i: R -> R, x -> x+3;
       REQUIRE(get_value(read_neumann_bc_descriptor).type() == IBoundaryConditionDescriptor::Type::neumann);
       REQUIRE(get_value(read_fourier_bc_descriptor).type() == IBoundaryConditionDescriptor::Type::fourier);
       REQUIRE(get_value(read_inflow_bc_descriptor).type() == IBoundaryConditionDescriptor::Type::inflow);
+      REQUIRE(get_value(read_inflow_list_bc_descriptor).type() == IBoundaryConditionDescriptor::Type::inflow_list);
 
       REQUIRE_NOTHROW(dynamic_cast<const AxisBoundaryConditionDescriptor&>(get_value(read_axis_bc_descriptor)));
       REQUIRE_NOTHROW(dynamic_cast<const SymmetryBoundaryConditionDescriptor&>(get_value(read_sym_bc_descriptor)));
+      REQUIRE_NOTHROW(dynamic_cast<const WallBoundaryConditionDescriptor&>(get_value(read_wall_bc_descriptor)));
       REQUIRE_NOTHROW(dynamic_cast<const OutflowBoundaryConditionDescriptor&>(get_value(read_outflow_bc_descriptor)));
       REQUIRE_NOTHROW(dynamic_cast<const FreeBoundaryConditionDescriptor&>(get_value(read_free_bc_descriptor)));
       REQUIRE_NOTHROW(dynamic_cast<const FixedBoundaryConditionDescriptor&>(get_value(read_fixed_bc_descriptor)));
@@ -266,9 +296,12 @@ let i: R -> R, x -> x+3;
       REQUIRE_NOTHROW(dynamic_cast<const NeumannBoundaryConditionDescriptor&>(get_value(read_neumann_bc_descriptor)));
       REQUIRE_NOTHROW(dynamic_cast<const FourierBoundaryConditionDescriptor&>(get_value(read_fourier_bc_descriptor)));
       REQUIRE_NOTHROW(dynamic_cast<const InflowBoundaryConditionDescriptor&>(get_value(read_inflow_bc_descriptor)));
+      REQUIRE_NOTHROW(
+        dynamic_cast<const InflowListBoundaryConditionDescriptor&>(get_value(read_inflow_list_bc_descriptor)));
 
       auto& read_axis_bc = dynamic_cast<const AxisBoundaryConditionDescriptor&>(get_value(read_axis_bc_descriptor));
       auto& read_sym_bc  = dynamic_cast<const SymmetryBoundaryConditionDescriptor&>(get_value(read_sym_bc_descriptor));
+      auto& read_wall_bc = dynamic_cast<const WallBoundaryConditionDescriptor&>(get_value(read_wall_bc_descriptor));
       auto& read_outflow_bc =
         dynamic_cast<const OutflowBoundaryConditionDescriptor&>(get_value(read_outflow_bc_descriptor));
       auto& read_free_bc  = dynamic_cast<const FreeBoundaryConditionDescriptor&>(get_value(read_free_bc_descriptor));
@@ -281,9 +314,12 @@ let i: R -> R, x -> x+3;
         dynamic_cast<const FourierBoundaryConditionDescriptor&>(get_value(read_fourier_bc_descriptor));
       auto& read_inflow_bc =
         dynamic_cast<const InflowBoundaryConditionDescriptor&>(get_value(read_inflow_bc_descriptor));
+      auto& read_inflow_list_bc =
+        dynamic_cast<const InflowListBoundaryConditionDescriptor&>(get_value(read_inflow_list_bc_descriptor));
 
       REQUIRE(read_axis_bc.boundaryDescriptor().type() == p_axis_bc_descriptor->boundaryDescriptor().type());
       REQUIRE(read_sym_bc.boundaryDescriptor().type() == p_sym_bc_descriptor->boundaryDescriptor().type());
+      REQUIRE(read_wall_bc.boundaryDescriptor().type() == p_wall_bc_descriptor->boundaryDescriptor().type());
       REQUIRE(read_outflow_bc.boundaryDescriptor().type() == p_outflow_bc_descriptor->boundaryDescriptor().type());
       REQUIRE(read_free_bc.boundaryDescriptor().type() == p_free_bc_descriptor->boundaryDescriptor().type());
       REQUIRE(read_fixed_bc.boundaryDescriptor().type() == p_fixed_bc_descriptor->boundaryDescriptor().type());
@@ -299,6 +335,12 @@ let i: R -> R, x -> x+3;
       REQUIRE(read_fourier_bc.rhsSymbolId().id() == p_fourier_bc_descriptor->rhsSymbolId().id());
       REQUIRE(read_inflow_bc.boundaryDescriptor().type() == p_inflow_bc_descriptor->boundaryDescriptor().type());
       REQUIRE(read_inflow_bc.functionSymbolId().id() == p_inflow_bc_descriptor->functionSymbolId().id());
+      REQUIRE(read_inflow_list_bc.boundaryDescriptor().type() ==
+              p_inflow_list_bc_descriptor->boundaryDescriptor().type());
+      for (size_t i = 0; i < read_inflow_list_bc.functionSymbolIdList().size(); ++i) {
+        REQUIRE(read_inflow_list_bc.functionSymbolIdList()[i].id() ==
+                p_inflow_list_bc_descriptor->functionSymbolIdList()[i].id());
+      }
 
       checkpointing::ResumingData::destroy();
       ast->m_symbol_table->clearValues();