Begin BC refactoring

Begin implementation of pressure boundary condition for acoustic solver

src/language/modules/SchemeModule.cpp

@@ -8,6 +8,7 @@
 #include <scheme/IBoundaryDescriptor.hpp>
 #include <scheme/NamedBoundaryDescriptor.hpp>
 #include <scheme/NumberedBoundaryDescriptor.hpp>
+#include <scheme/PressureBoundaryConditionDescriptor.hpp>
 #include <scheme/SymmetryBoundaryConditionDescriptor.hpp>
 
 #include <memory>
@@ -106,6 +107,25 @@ struct GlaceScheme
           }
           break;
         }
+        case IBoundaryConditionDescriptor::Type::pressure: {
+          const PressureBoundaryConditionDescriptor& pressure_bc_descriptor =
+            dynamic_cast<const PressureBoundaryConditionDescriptor&>(*bc_descriptor);
+          for (size_t i_ref_face_list = 0;
+               i_ref_face_list < m_mesh->connectivity().template numberOfRefItemList<FaceType>(); ++i_ref_face_list) {
+            const auto& ref_face_list = m_mesh->connectivity().template refItemList<FaceType>(i_ref_face_list);
+            const RefId& ref          = ref_face_list.refId();
+            if (ref == pressure_bc_descriptor.boundaryDescriptor()) {
+              const auto& face_list = ref_face_list.list();
+              Array<double> face_values{face_list.size()};
+              face_values.fill(1);
+
+              std::shared_ptr bc =
+                std::make_shared<PressureBoundaryCondition<MeshType::Dimension>>(face_list, face_values);
+              bc_list.push_back(BoundaryConditionHandler(bc));
+            }
+          }
+          break;
+        }
         default: {
           throw UnexpectedError("Unknown BCDescription\n");
         }
@@ -247,6 +267,19 @@ SchemeModule::SchemeModule()
 
                             ));
 
+  this->_addBuiltinFunction("pressure",
+                            std::make_shared<BuiltinFunctionEmbedder<std::shared_ptr<
+                              const IBoundaryConditionDescriptor>(std::shared_ptr<const IBoundaryDescriptor>,
+                                                                  const FunctionSymbolId&)>>(
+
+                              [](std::shared_ptr<const IBoundaryDescriptor> boundary,
+                                 const FunctionSymbolId& pressure_id)
+                                -> std::shared_ptr<const IBoundaryConditionDescriptor> {
+                                return std::make_shared<PressureBoundaryConditionDescriptor>(boundary, pressure_id);
+                              }
+
+                              ));
+
   this->_addBuiltinFunction("glace",
                             std::make_shared<BuiltinFunctionEmbedder<
                               void(std::shared_ptr<const IMesh>,

src/scheme/AcousticSolver.hpp

@@ -130,7 +130,31 @@ class AcousticSolver
         throw NotImplementedError("velocity BC");
       }
       case BoundaryCondition::pressure: {
-        throw NotImplementedError("pressure BC");
+        const PressureBoundaryCondition<Dimension>& pressure_bc =
+          dynamic_cast<const PressureBoundaryCondition<Dimension>&>(handler.boundaryCondition());
+        if constexpr (Dimension == 1) {
+          MeshData<Dimension>& mesh_data       = MeshDataManager::instance().getMeshData(*m_mesh);
+          const NodeValuePerCell<const Rd> Cjr = mesh_data.Cjr();
+
+          const auto& node_to_cell_matrix               = m_connectivity.nodeToCellMatrix();
+          const auto& node_local_numbers_in_their_cells = m_connectivity.nodeLocalNumbersInTheirCells();
+
+          const auto& node_list  = pressure_bc.faceList();
+          const auto& value_list = pressure_bc.valueList();
+          for (size_t i_node = 0; i_node < node_list.size(); ++i_node) {
+            const NodeId node_id       = node_list[i_node];
+            const auto& node_cell_list = node_to_cell_matrix[node_id];
+            Assert(node_cell_list.size() == 1);
+
+            CellId node_cell_id              = node_cell_list[0];
+            size_t node_local_number_in_cell = node_local_numbers_in_their_cells(node_id, 0);
+
+            m_br[node_id] -= value_list[i_node] * Cjr(node_cell_id, node_local_number_in_cell);
+          }
+        } else {
+          throw NotImplementedError("pressure bc in dimension>1");
+        }
+        break;
       }
       case BoundaryCondition::symmetry: {
         const SymmetryBoundaryCondition<Dimension>& symmetry_bc =

src/scheme/BoundaryCondition.hpp

@@ -38,42 +38,57 @@ class BoundaryCondition   // clazy:exclude=copyable-polymorphic
   virtual ~BoundaryCondition() = default;
 };
 
+template <size_t Dimension>
 class PressureBoundaryCondition final : public BoundaryCondition   // clazy:exclude=copyable-polymorphic
 {
  private:
-  const double m_value;
-
-  const size_t m_number_of_faces;
-  Array<const unsigned int> m_face_list;
+  const Array<const double> m_value_list;
+  const Array<const FaceId> m_face_list;
 
  public:
-  double
-  value() const
+  const Array<const FaceId>&
+  faceList() const
   {
-    return m_value;
+    return m_face_list;
   }
 
-  const size_t&
-  numberOfFaces() const
+  const Array<const double>&
+  valueList() const
   {
-    return m_number_of_faces;
+    return m_value_list;
   }
 
-  const Array<const unsigned int>&
+  PressureBoundaryCondition(const Array<const FaceId>& face_list, Array<const double> value_list)
+    : BoundaryCondition{BoundaryCondition::pressure}, m_value_list{value_list}, m_face_list{face_list}
+  {}
+
+  ~PressureBoundaryCondition() = default;
+};
+
+template <>
+class PressureBoundaryCondition<1> final : public BoundaryCondition   // clazy:exclude=copyable-polymorphic
+{
+ private:
+  const Array<const double> m_value_list;
+  const Array<const NodeId> m_face_list;
+
+ public:
+  const Array<const NodeId>&
   faceList() const
   {
     return m_face_list;
   }
 
-  PressureBoundaryCondition(double value, const std::vector<unsigned int>& faces)
-    : BoundaryCondition(BoundaryCondition::pressure), m_value(value), m_number_of_faces(faces.size())
+  const Array<const double>&
+  valueList() const
   {
-    Array<unsigned int> face_list(faces.size());
-    parallel_for(
-      m_number_of_faces, PUGS_LAMBDA(int f) { face_list[f] = faces[f]; });
-    m_face_list = face_list;
+    return m_value_list;
   }
 
+  PressureBoundaryCondition(const Array<const NodeId>& face_list, Array<const double> value_list)
+    : BoundaryCondition{BoundaryCondition::pressure}, m_value_list{value_list}, m_face_list{face_list}
+  {}
+
   ~PressureBoundaryCondition() = default;
 };
 

src/scheme/IBoundaryConditionDescriptor.hpp

@@ -8,6 +8,7 @@ class IBoundaryConditionDescriptor
  public:
   enum class Type
   {
+    pressure,
     symmetry
   };
 

src/scheme/PressureBoundaryConditionDescriptor.hpp

+#ifndef PRESSURE_BOUNDARY_CONDITION_DESCRIPTOR_HPP
+#define PRESSURE_BOUNDARY_CONDITION_DESCRIPTOR_HPP
+
+#include <language/utils/FunctionSymbolId.hpp>
+#include <scheme/IBoundaryConditionDescriptor.hpp>
+#include <scheme/IBoundaryDescriptor.hpp>
+
+#include <memory>
+
+class PressureBoundaryConditionDescriptor : public IBoundaryConditionDescriptor
+{
+ private:
+  std::ostream&
+  _write(std::ostream& os) const final
+  {
+    os << "pressure(" << *m_boundary_descriptor << ")";
+    return os;
+  }
+
+  std::shared_ptr<const IBoundaryDescriptor> m_boundary_descriptor;
+  const FunctionSymbolId m_function_symbol_id;
+
+ public:
+  const IBoundaryDescriptor&
+  boundaryDescriptor() const
+  {
+    return *m_boundary_descriptor;
+  }
+
+  Type
+  type() const final
+  {
+    return Type::pressure;
+  }
+
+  PressureBoundaryConditionDescriptor(std::shared_ptr<const IBoundaryDescriptor> boundary_descriptor,
+                                      const FunctionSymbolId& function_symbol_id)
+    : m_boundary_descriptor(boundary_descriptor), m_function_symbol_id{function_symbol_id}
+  {
+    ;
+  }
+
+  PressureBoundaryConditionDescriptor(const PressureBoundaryConditionDescriptor&) = delete;
+  PressureBoundaryConditionDescriptor(PressureBoundaryConditionDescriptor&&)      = delete;
+
+  ~PressureBoundaryConditionDescriptor() = default;
+};
+
+#endif   // PRESSURE_BOUNDARY_CONDITION_DESCRIPTOR_HPP