diff --git a/src/language/algorithms/AcousticSolverAlgorithm.cpp b/src/language/algorithms/AcousticSolverAlgorithm.cpp
index 1a11de171d8172f9f276718d0624cd31b38312f4..9811c90f0b0f2c52d5f72369efea4a4398f007e3 100644
--- a/src/language/algorithms/AcousticSolverAlgorithm.cpp
+++ b/src/language/algorithms/AcousticSolverAlgorithm.cpp
@@ -1,5 +1,12 @@
 #include <language/algorithms/AcousticSolverAlgorithm.hpp>
 
+#include <language/utils/InterpolateItemValue.hpp>
+#include <output/VTKWriter.hpp>
+#include <scheme/AcousticSolver.hpp>
+#include <scheme/DirichletBoundaryConditionDescriptor.hpp>
+#include <scheme/IBoundaryDescriptor.hpp>
+#include <scheme/SymmetryBoundaryConditionDescriptor.hpp>
+
 template <size_t Dimension>
 AcousticSolverAlgorithm<Dimension>::AcousticSolverAlgorithm(
   const AcousticSolverType& solver_type,
@@ -9,9 +16,12 @@ AcousticSolverAlgorithm<Dimension>::AcousticSolverAlgorithm(
   const FunctionSymbolId& u_id,
   const FunctionSymbolId& p_id)
 {
-  std::shared_ptr<const MeshType> mesh = std::dynamic_pointer_cast<const MeshType>(i_mesh);
+  using ConnectivityType = Connectivity<Dimension>;
+  using MeshType         = Mesh<ConnectivityType>;
+  using MeshDataType     = MeshData<Dimension>;
+  using UnknownsType     = FiniteVolumesEulerUnknowns<MeshType>;
 
-  std::cout << "number of bc descr = " << bc_descriptor_list.size() << '\n';
+  std::shared_ptr<const MeshType> mesh = std::dynamic_pointer_cast<const MeshType>(i_mesh);
 
   typename AcousticSolver<MeshType>::BoundaryConditionList bc_list;
   {
@@ -24,6 +34,8 @@ AcousticSolverAlgorithm<Dimension>::AcousticSolverAlgorithm(
     }();
 
     for (const auto& bc_descriptor : bc_descriptor_list) {
+      bool is_valid_boundary_condition = true;
+
       switch (bc_descriptor->type()) {
       case IBoundaryConditionDescriptor::Type::symmetry: {
         using SymmetryBoundaryCondition = typename AcousticSolver<MeshType>::SymmetryBoundaryCondition;
@@ -39,72 +51,74 @@ AcousticSolverAlgorithm<Dimension>::AcousticSolverAlgorithm(
               SymmetryBoundaryCondition{MeshFlatNodeBoundary<MeshType::Dimension>(mesh, ref_face_list)});
           }
         }
+        is_valid_boundary_condition = true;
         break;
       }
-      case IBoundaryConditionDescriptor::Type::velocity: {
-        using VelocityBoundaryCondition = typename AcousticSolver<MeshType>::VelocityBoundaryCondition;
 
-        const VelocityBoundaryConditionDescriptor& velocity_bc_descriptor =
-          dynamic_cast<const VelocityBoundaryConditionDescriptor&>(*bc_descriptor);
-        for (size_t i_ref_face_list = 0;
-             i_ref_face_list < mesh->connectivity().template numberOfRefItemList<FaceType>(); ++i_ref_face_list) {
-          const auto& ref_face_list = mesh->connectivity().template refItemList<FaceType>(i_ref_face_list);
-          const RefId& ref          = ref_face_list.refId();
-          if (ref == velocity_bc_descriptor.boundaryDescriptor()) {
-            MeshNodeBoundary<Dimension> mesh_node_boundary{mesh, ref_face_list};
+      case IBoundaryConditionDescriptor::Type::dirichlet: {
+        const DirichletBoundaryConditionDescriptor& dirichlet_bc_descriptor =
+          dynamic_cast<const DirichletBoundaryConditionDescriptor&>(*bc_descriptor);
+        if (dirichlet_bc_descriptor.name() == "velocity") {
+          using VelocityBoundaryCondition = typename AcousticSolver<MeshType>::VelocityBoundaryCondition;
 
-            const FunctionSymbolId velocity_id = velocity_bc_descriptor.functionSymbolId();
+          for (size_t i_ref_face_list = 0;
+               i_ref_face_list < mesh->connectivity().template numberOfRefItemList<FaceType>(); ++i_ref_face_list) {
+            const auto& ref_face_list = mesh->connectivity().template refItemList<FaceType>(i_ref_face_list);
+            const RefId& ref          = ref_face_list.refId();
+            if (ref == dirichlet_bc_descriptor.boundaryDescriptor()) {
+              MeshNodeBoundary<Dimension> mesh_node_boundary{mesh, ref_face_list};
 
-            const auto& node_list = mesh_node_boundary.nodeList();
+              const FunctionSymbolId velocity_id = dirichlet_bc_descriptor.rhsSymbolId();
 
-            Array<const TinyVector<Dimension>> value_list = InterpolateItemValue<TinyVector<Dimension>(
-              TinyVector<Dimension>)>::template interpolate<ItemType::node>(velocity_id, mesh->xr(), node_list);
+              const auto& node_list = mesh_node_boundary.nodeList();
 
-            bc_list.push_back(VelocityBoundaryCondition{node_list, value_list});
-          }
-        }
-        break;
-      }
-      case IBoundaryConditionDescriptor::Type::pressure: {
-        using PressureBoundaryCondition = typename AcousticSolver<MeshType>::PressureBoundaryCondition;
+              Array<const TinyVector<Dimension>> value_list = InterpolateItemValue<TinyVector<Dimension>(
+                TinyVector<Dimension>)>::template interpolate<ItemType::node>(velocity_id, mesh->xr(), node_list);
 
-        const PressureBoundaryConditionDescriptor& pressure_bc_descriptor =
-          dynamic_cast<const PressureBoundaryConditionDescriptor&>(*bc_descriptor);
-        for (size_t i_ref_face_list = 0;
-             i_ref_face_list < mesh->connectivity().template numberOfRefItemList<FaceType>(); ++i_ref_face_list) {
-          const auto& ref_face_list = 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();
-
-            const FunctionSymbolId pressure_id = pressure_bc_descriptor.functionSymbolId();
-
-            Array<const double> face_values = [&] {
-              if constexpr (Dimension == 1) {
-                return InterpolateItemValue<double(TinyVector<Dimension>)>::template interpolate<FaceType>(pressure_id,
-                                                                                                           mesh->xr(),
-                                                                                                           face_list);
-              } else {
-                MeshDataType& mesh_data = MeshDataManager::instance().getMeshData(*mesh);
-
-                return InterpolateItemValue<double(TinyVector<Dimension>)>::template interpolate<FaceType>(pressure_id,
-                                                                                                           mesh_data
-                                                                                                             .xl(),
-                                                                                                           face_list);
-              }
-            }();
-
-            bc_list.push_back(PressureBoundaryCondition{face_list, face_values});
+              bc_list.push_back(VelocityBoundaryCondition{node_list, value_list});
+            }
+          }
+        } else if (dirichlet_bc_descriptor.name() == "pressure") {
+          using PressureBoundaryCondition = typename AcousticSolver<MeshType>::PressureBoundaryCondition;
+
+          for (size_t i_ref_face_list = 0;
+               i_ref_face_list < mesh->connectivity().template numberOfRefItemList<FaceType>(); ++i_ref_face_list) {
+            const auto& ref_face_list = mesh->connectivity().template refItemList<FaceType>(i_ref_face_list);
+            const RefId& ref          = ref_face_list.refId();
+            if (ref == dirichlet_bc_descriptor.boundaryDescriptor()) {
+              const auto& face_list = ref_face_list.list();
+
+              const FunctionSymbolId pressure_id = dirichlet_bc_descriptor.rhsSymbolId();
+
+              Array<const double> face_values = [&] {
+                if constexpr (Dimension == 1) {
+                  return InterpolateItemValue<double(
+                    TinyVector<Dimension>)>::template interpolate<FaceType>(pressure_id, mesh->xr(), face_list);
+                } else {
+                  MeshDataType& mesh_data = MeshDataManager::instance().getMeshData(*mesh);
+
+                  return InterpolateItemValue<double(
+                    TinyVector<Dimension>)>::template interpolate<FaceType>(pressure_id, mesh_data.xl(), face_list);
+                }
+              }();
+
+              bc_list.push_back(PressureBoundaryCondition{face_list, face_values});
+            }
           }
+        } else {
+          is_valid_boundary_condition = false;
         }
         break;
       }
       default: {
+        is_valid_boundary_condition = false;
+      }
+      }
+      if (not is_valid_boundary_condition) {
         std::ostringstream error_msg;
         error_msg << *bc_descriptor << " is an invalid boundary condition for acoustic solver";
         throw NormalError(error_msg.str());
       }
-      }
     }
   }
 
diff --git a/src/language/algorithms/AcousticSolverAlgorithm.hpp b/src/language/algorithms/AcousticSolverAlgorithm.hpp
index bb9d9ef66d176274d305a02067e4f299c71d2c78..a6973480c4cd913c6463d39012f6eea906540003 100644
--- a/src/language/algorithms/AcousticSolverAlgorithm.hpp
+++ b/src/language/algorithms/AcousticSolverAlgorithm.hpp
@@ -2,23 +2,13 @@
 #define ACOUSTIC_SOLVER_ALGORITHM_HPP
 
 #include <language/utils/FunctionSymbolId.hpp>
-#include <language/utils/InterpolateItemValue.hpp>
-#include <output/VTKWriter.hpp>
-#include <scheme/AcousticSolver.hpp>
+#include <mesh/IMesh.hpp>
+#include <scheme/AcousticSolverType.hpp>
 #include <scheme/IBoundaryConditionDescriptor.hpp>
-#include <scheme/IBoundaryDescriptor.hpp>
-#include <scheme/PressureBoundaryConditionDescriptor.hpp>
-#include <scheme/SymmetryBoundaryConditionDescriptor.hpp>
-#include <scheme/VelocityBoundaryConditionDescriptor.hpp>
 
 template <size_t Dimension>
 struct AcousticSolverAlgorithm
 {
-  using ConnectivityType = Connectivity<Dimension>;
-  using MeshType         = Mesh<ConnectivityType>;
-  using MeshDataType     = MeshData<Dimension>;
-  using UnknownsType     = FiniteVolumesEulerUnknowns<MeshType>;
-
   AcousticSolverAlgorithm(const AcousticSolverType& solver_type,
                           std::shared_ptr<const IMesh> i_mesh,
                           const std::vector<std::shared_ptr<const IBoundaryConditionDescriptor>>& bc_descriptor_list,
diff --git a/src/language/modules/SchemeModule.cpp b/src/language/modules/SchemeModule.cpp
index 0bdf7de8ec290730ff10595ba1f4866978bbb333..a6dcec9c8d510e36a8b70547eafbf11775acef8a 100644
--- a/src/language/modules/SchemeModule.cpp
+++ b/src/language/modules/SchemeModule.cpp
@@ -4,11 +4,14 @@
 #include <language/utils/BuiltinFunctionEmbedder.hpp>
 #include <language/utils/TypeDescriptor.hpp>
 #include <mesh/Mesh.hpp>
-#include <scheme/AcousticSolver.hpp>
+#include <scheme/DirichletBoundaryConditionDescriptor.hpp>
+#include <scheme/FourierBoundaryConditionDescriptor.hpp>
 #include <scheme/IBoundaryConditionDescriptor.hpp>
 #include <scheme/IBoundaryDescriptor.hpp>
 #include <scheme/NamedBoundaryDescriptor.hpp>
+#include <scheme/NeumannBoundaryConditionDescriptor.hpp>
 #include <scheme/NumberedBoundaryDescriptor.hpp>
+#include <scheme/SymmetryBoundaryConditionDescriptor.hpp>
 
 #include <memory>
 
@@ -57,7 +60,8 @@ SchemeModule::SchemeModule()
                               [](std::shared_ptr<const IBoundaryDescriptor> boundary,
                                  const FunctionSymbolId& pressure_id)
                                 -> std::shared_ptr<const IBoundaryConditionDescriptor> {
-                                return std::make_shared<PressureBoundaryConditionDescriptor>(boundary, pressure_id);
+                                return std::make_shared<DirichletBoundaryConditionDescriptor>("pressure", boundary,
+                                                                                              pressure_id);
                               }
 
                               ));
@@ -70,7 +74,8 @@ SchemeModule::SchemeModule()
                               [](std::shared_ptr<const IBoundaryDescriptor> boundary,
                                  const FunctionSymbolId& velocity_id)
                                 -> std::shared_ptr<const IBoundaryConditionDescriptor> {
-                                return std::make_shared<VelocityBoundaryConditionDescriptor>(boundary, velocity_id);
+                                return std::make_shared<DirichletBoundaryConditionDescriptor>("velocity", boundary,
+                                                                                              velocity_id);
                               }
 
                               ));
diff --git a/src/scheme/AcousticSolver.hpp b/src/scheme/AcousticSolver.hpp
index 1e246f2dbf054715d67e80819078ed84b9441785..3e3151d25429593955cb281c2dd814690f67bfa5 100644
--- a/src/scheme/AcousticSolver.hpp
+++ b/src/scheme/AcousticSolver.hpp
@@ -9,6 +9,7 @@
 #include <mesh/MeshDataManager.hpp>
 #include <mesh/MeshNodeBoundary.hpp>
 #include <mesh/SubItemValuePerItem.hpp>
+#include <scheme/AcousticSolverType.hpp>
 #include <scheme/BlockPerfectGas.hpp>
 #include <scheme/FiniteVolumesEulerUnknowns.hpp>
 #include <utils/ArrayUtils.hpp>
@@ -20,12 +21,6 @@
 
 #include <iostream>
 
-enum class AcousticSolverType
-{
-  Eucclhyd,
-  Glace
-};
-
 template <typename MeshType>
 class AcousticSolver
 {
diff --git a/src/scheme/AcousticSolverType.hpp b/src/scheme/AcousticSolverType.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..3095dcc864d5598e985290302ad94106adbd6b2e
--- /dev/null
+++ b/src/scheme/AcousticSolverType.hpp
@@ -0,0 +1,10 @@
+#ifndef ACOUSTIC_SOLVER_TYPE_HPP
+#define ACOUSTIC_SOLVER_TYPE_HPP
+
+enum class AcousticSolverType
+{
+  Eucclhyd,
+  Glace
+};
+
+#endif   // ACOUSTIC_SOLVER_TYPE_HPP
diff --git a/src/scheme/DirichletBoundaryConditionDescriptor.hpp b/src/scheme/DirichletBoundaryConditionDescriptor.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..5fa6c42f9d4b5333ad1ca5ef2fdb46a4f06b4242
--- /dev/null
+++ b/src/scheme/DirichletBoundaryConditionDescriptor.hpp
@@ -0,0 +1,64 @@
+#ifndef DIRICHLET_BOUNDARY_CONDITION_DESCRIPTOR_HPP
+#define DIRICHLET_BOUNDARY_CONDITION_DESCRIPTOR_HPP
+
+#include <language/utils/FunctionSymbolId.hpp>
+#include <scheme/IBoundaryConditionDescriptor.hpp>
+#include <scheme/IBoundaryDescriptor.hpp>
+
+#include <memory>
+
+class DirichletBoundaryConditionDescriptor : public IBoundaryConditionDescriptor
+{
+ private:
+  std::ostream&
+  _write(std::ostream& os) const final
+  {
+    os << "dirichlet(" << m_name << ',' << *m_boundary_descriptor << ")";
+    return os;
+  }
+
+  const std::string_view m_name;
+
+  std::shared_ptr<const IBoundaryDescriptor> m_boundary_descriptor;
+  const FunctionSymbolId m_rhs_symbol_id;
+
+ public:
+  std::string_view
+  name() const
+  {
+    return m_name;
+  }
+
+  FunctionSymbolId
+  rhsSymbolId() const
+  {
+    return m_rhs_symbol_id;
+  }
+
+  const IBoundaryDescriptor&
+  boundaryDescriptor() const
+  {
+    return *m_boundary_descriptor;
+  }
+
+  Type
+  type() const final
+  {
+    return Type::dirichlet;
+  }
+
+  DirichletBoundaryConditionDescriptor(const std::string_view name,
+                                       std::shared_ptr<const IBoundaryDescriptor> boundary_descriptor,
+                                       const FunctionSymbolId& rhs_symbol_id)
+    : m_name{name}, m_boundary_descriptor(boundary_descriptor), m_rhs_symbol_id{rhs_symbol_id}
+  {
+    ;
+  }
+
+  DirichletBoundaryConditionDescriptor(const DirichletBoundaryConditionDescriptor&) = delete;
+  DirichletBoundaryConditionDescriptor(DirichletBoundaryConditionDescriptor&&)      = delete;
+
+  ~DirichletBoundaryConditionDescriptor() = default;
+};
+
+#endif   // DIRICHLET_BOUNDARY_CONDITION_DESCRIPTOR_HPP
diff --git a/src/scheme/FourierBoundaryConditionDescriptor.hpp b/src/scheme/FourierBoundaryConditionDescriptor.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..e7aeb830c3447bcf9783060210bc97e59bf2ebdf
--- /dev/null
+++ b/src/scheme/FourierBoundaryConditionDescriptor.hpp
@@ -0,0 +1,75 @@
+#ifndef FOURIER_BOUNDARY_CONDITION_DESCRIPTOR_HPP
+#define FOURIER_BOUNDARY_CONDITION_DESCRIPTOR_HPP
+
+#include <language/utils/FunctionSymbolId.hpp>
+#include <scheme/IBoundaryConditionDescriptor.hpp>
+#include <scheme/IBoundaryDescriptor.hpp>
+
+#include <memory>
+
+class FourierBoundaryConditionDescriptor : public IBoundaryConditionDescriptor
+{
+ private:
+  std::ostream&
+  _write(std::ostream& os) const final
+  {
+    os << "fourier(" << m_name << ',' << *m_boundary_descriptor << ")";
+    return os;
+  }
+
+  const std::string_view m_name;
+
+  std::shared_ptr<const IBoundaryDescriptor> m_boundary_descriptor;
+  const FunctionSymbolId m_mass_symbol_id;
+  const FunctionSymbolId m_rhs_symbol_id;
+
+ public:
+  std::string_view
+  name() const
+  {
+    return m_name;
+  }
+
+  FunctionSymbolId
+  massSymbolId() const
+  {
+    return m_mass_symbol_id;
+  }
+
+  FunctionSymbolId
+  rhsSymbolId() const
+  {
+    return m_rhs_symbol_id;
+  }
+
+  const IBoundaryDescriptor&
+  boundaryDescriptor() const
+  {
+    return *m_boundary_descriptor;
+  }
+
+  Type
+  type() const final
+  {
+    return Type::fourier;
+  }
+
+  FourierBoundaryConditionDescriptor(const std::string_view name,
+                                     std::shared_ptr<const IBoundaryDescriptor> boundary_descriptor,
+                                     const FunctionSymbolId& mass_symbol_id,
+                                     const FunctionSymbolId& rhs_symbol_id)
+    : m_name{name},
+      m_boundary_descriptor(boundary_descriptor),
+      m_mass_symbol_id{mass_symbol_id},
+      m_rhs_symbol_id{rhs_symbol_id}
+  {
+    ;
+  }
+
+  FourierBoundaryConditionDescriptor(const FourierBoundaryConditionDescriptor&) = delete;
+  FourierBoundaryConditionDescriptor(FourierBoundaryConditionDescriptor&&)      = delete;
+
+  ~FourierBoundaryConditionDescriptor() = default;
+};
+
+#endif   // FOURIER_BOUNDARY_CONDITION_DESCRIPTOR_HPP
diff --git a/src/scheme/IBoundaryConditionDescriptor.hpp b/src/scheme/IBoundaryConditionDescriptor.hpp
index 95f68bd2575db1ce87b6657e32e1d7863297a8ae..be25ba73180f001ee264e9087379dc15ee03f378 100644
--- a/src/scheme/IBoundaryConditionDescriptor.hpp
+++ b/src/scheme/IBoundaryConditionDescriptor.hpp
@@ -8,8 +8,9 @@ class IBoundaryConditionDescriptor
  public:
   enum class Type
   {
-    velocity,
-    pressure,
+    dirichlet,
+    fourier,
+    neumann,
     symmetry
   };
 
diff --git a/src/scheme/NeumannBoundaryConditionDescriptor.hpp b/src/scheme/NeumannBoundaryConditionDescriptor.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..edc1b1fb35b3f530c47adcd2f0073c9727707965
--- /dev/null
+++ b/src/scheme/NeumannBoundaryConditionDescriptor.hpp
@@ -0,0 +1,64 @@
+#ifndef NEUMANN_BOUNDARY_CONDITION_DESCRIPTOR_HPP
+#define NEUMANN_BOUNDARY_CONDITION_DESCRIPTOR_HPP
+
+#include <language/utils/FunctionSymbolId.hpp>
+#include <scheme/IBoundaryConditionDescriptor.hpp>
+#include <scheme/IBoundaryDescriptor.hpp>
+
+#include <memory>
+
+class NeumannBoundaryConditionDescriptor : public IBoundaryConditionDescriptor
+{
+ private:
+  std::ostream&
+  _write(std::ostream& os) const final
+  {
+    os << "neumann(" << m_name << ',' << *m_boundary_descriptor << ")";
+    return os;
+  }
+
+  const std::string_view m_name;
+
+  std::shared_ptr<const IBoundaryDescriptor> m_boundary_descriptor;
+  const FunctionSymbolId m_rhs_symbol_id;
+
+ public:
+  std::string_view
+  name() const
+  {
+    return m_name;
+  }
+
+  FunctionSymbolId
+  rhsSymbolId() const
+  {
+    return m_rhs_symbol_id;
+  }
+
+  const IBoundaryDescriptor&
+  boundaryDescriptor() const
+  {
+    return *m_boundary_descriptor;
+  }
+
+  Type
+  type() const final
+  {
+    return Type::neumann;
+  }
+
+  NeumannBoundaryConditionDescriptor(const std::string_view name,
+                                     std::shared_ptr<const IBoundaryDescriptor> boundary_descriptor,
+                                     const FunctionSymbolId& rhs_symbol_id)
+    : m_name{name}, m_boundary_descriptor(boundary_descriptor), m_rhs_symbol_id{rhs_symbol_id}
+  {
+    ;
+  }
+
+  NeumannBoundaryConditionDescriptor(const NeumannBoundaryConditionDescriptor&) = delete;
+  NeumannBoundaryConditionDescriptor(NeumannBoundaryConditionDescriptor&&)      = delete;
+
+  ~NeumannBoundaryConditionDescriptor() = default;
+};
+
+#endif   // NEUMANN_BOUNDARY_CONDITION_DESCRIPTOR_HPP
diff --git a/src/scheme/PressureBoundaryConditionDescriptor.hpp b/src/scheme/PressureBoundaryConditionDescriptor.hpp
deleted file mode 100644
index 8a3d39f5138e05fa41e856ebd676a0cc0c729767..0000000000000000000000000000000000000000
--- a/src/scheme/PressureBoundaryConditionDescriptor.hpp
+++ /dev/null
@@ -1,55 +0,0 @@
-#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:
-  FunctionSymbolId
-  functionSymbolId() const
-  {
-    return m_function_symbol_id;
-  }
-
-  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
diff --git a/src/scheme/VelocityBoundaryConditionDescriptor.hpp b/src/scheme/VelocityBoundaryConditionDescriptor.hpp
deleted file mode 100644
index 5ce10e6a5ace389db0526ad3c5bd9fac31e80c9d..0000000000000000000000000000000000000000
--- a/src/scheme/VelocityBoundaryConditionDescriptor.hpp
+++ /dev/null
@@ -1,55 +0,0 @@
-#ifndef VELOCITY_BOUNDARY_CONDITION_DESCRIPTOR_HPP
-#define VELOCITY_BOUNDARY_CONDITION_DESCRIPTOR_HPP
-
-#include <language/utils/FunctionSymbolId.hpp>
-#include <scheme/IBoundaryConditionDescriptor.hpp>
-#include <scheme/IBoundaryDescriptor.hpp>
-
-#include <memory>
-
-class VelocityBoundaryConditionDescriptor : public IBoundaryConditionDescriptor
-{
- private:
-  std::ostream&
-  _write(std::ostream& os) const final
-  {
-    os << "velocity(" << *m_boundary_descriptor << ")";
-    return os;
-  }
-
-  std::shared_ptr<const IBoundaryDescriptor> m_boundary_descriptor;
-  const FunctionSymbolId m_function_symbol_id;
-
- public:
-  FunctionSymbolId
-  functionSymbolId() const
-  {
-    return m_function_symbol_id;
-  }
-
-  const IBoundaryDescriptor&
-  boundaryDescriptor() const
-  {
-    return *m_boundary_descriptor;
-  }
-
-  Type
-  type() const final
-  {
-    return Type::velocity;
-  }
-
-  VelocityBoundaryConditionDescriptor(std::shared_ptr<const IBoundaryDescriptor> boundary_descriptor,
-                                      const FunctionSymbolId& function_symbol_id)
-    : m_boundary_descriptor(boundary_descriptor), m_function_symbol_id{function_symbol_id}
-  {
-    ;
-  }
-
-  VelocityBoundaryConditionDescriptor(const VelocityBoundaryConditionDescriptor&) = delete;
-  VelocityBoundaryConditionDescriptor(VelocityBoundaryConditionDescriptor&&)      = delete;
-
-  ~VelocityBoundaryConditionDescriptor() = default;
-};
-
-#endif   // VELOCITY!_BOUNDARY_CONDITION_DESCRIPTOR_HPP