Allow to associate a variable to a list of boundary conditions

This is done through the `VariableBCDescriptor` type in C++ which reads
`variable_boundary_condition` in the scripting language.

Also add the following pgs-function:
  variable_bc: Vh * (boundary_condition) -> variable_boundary_condition

src/language/modules/SchemeModule.cpp

@@ -37,8 +37,11 @@
 #include <scheme/HyperelasticSolver.hpp>
 #include <scheme/IBoundaryConditionDescriptor.hpp>
 #include <scheme/IDiscreteFunctionDescriptor.hpp>
+#include <scheme/InflowBoundaryConditionDescriptor.hpp>
 #include <scheme/NeumannBoundaryConditionDescriptor.hpp>
+#include <scheme/OutflowBoundaryConditionDescriptor.hpp>
 #include <scheme/SymmetryBoundaryConditionDescriptor.hpp>
+#include <scheme/VariableBCDescriptor.hpp>
 #include <utils/Socket.hpp>
 
 #include <memory>
@@ -50,6 +53,7 @@ SchemeModule::SchemeModule()
   this->_addTypeDescriptor(ast_node_data_type_from<std::shared_ptr<const IQuadratureDescriptor>>);
 
   this->_addTypeDescriptor(ast_node_data_type_from<std::shared_ptr<const IBoundaryConditionDescriptor>>);
+  this->_addTypeDescriptor(ast_node_data_type_from<std::shared_ptr<const VariableBCDescriptor>>);
 
   this->_addBuiltinFunction("P0", std::function(
 
@@ -75,6 +79,16 @@ SchemeModule::SchemeModule()
 
                                        ));
 
+  this->_addBuiltinFunction("variable_bc", std::function(
+
+                                             [](const std::shared_ptr<const DiscreteFunctionVariant>& v,
+                                                const std::vector<std::shared_ptr<const IBoundaryConditionDescriptor>>&
+                                                  bc_descriptor_list) -> std::shared_ptr<const VariableBCDescriptor> {
+                                               return std::make_shared<VariableBCDescriptor>(v, bc_descriptor_list);
+                                             }
+
+                                             ));
+
   this->_addBuiltinFunction("GaussLobatto", std::function(
 
                                               [](uint64_t degree) -> std::shared_ptr<const IQuadratureDescriptor> {
@@ -367,6 +381,26 @@ SchemeModule::SchemeModule()
 
                               ));
 
+  this->_addBuiltinFunction("inflow", std::function(
+
+                                        [](std::shared_ptr<const IBoundaryDescriptor> boundary,
+                                           const FunctionSymbolId& function_id)
+                                          -> std::shared_ptr<const IBoundaryConditionDescriptor> {
+                                          return std::make_shared<InflowBoundaryConditionDescriptor>(boundary,
+                                                                                                     function_id);
+                                        }
+
+                                        ));
+
+  this->_addBuiltinFunction("outflow", std::function(
+
+                                         [](std::shared_ptr<const IBoundaryDescriptor> boundary)
+                                           -> std::shared_ptr<const IBoundaryConditionDescriptor> {
+                                           return std::make_shared<OutflowBoundaryConditionDescriptor>(boundary);
+                                         }
+
+                                         ));
+
   this->_addBuiltinFunction("glace_fluxes", std::function(
 
                                               [](const std::shared_ptr<const DiscreteFunctionVariant>& rho,

src/language/modules/SchemeModule.hpp

@@ -10,6 +10,11 @@ template <>
 inline ASTNodeDataType ast_node_data_type_from<std::shared_ptr<const IBoundaryConditionDescriptor>> =
   ASTNodeDataType::build<ASTNodeDataType::type_id_t>("boundary_condition");
 
+class VariableBCDescriptor;
+template <>
+inline ASTNodeDataType ast_node_data_type_from<std::shared_ptr<const VariableBCDescriptor>> =
+  ASTNodeDataType::build<ASTNodeDataType::type_id_t>("variable_boundary_condition");
+
 class DiscreteFunctionVariant;
 template <>
 inline ASTNodeDataType ast_node_data_type_from<std::shared_ptr<const DiscreteFunctionVariant>> =

src/scheme/VariableBCDescriptor.hpp

+#ifndef VARIABLE_BC_DESCRIPTOR_HPP
+#define VARIABLE_BC_DESCRIPTOR_HPP
+
+class DiscreteFunctionVariant;
+class IBoundaryConditionDescriptor;
+
+#include <memory>
+#include <vector>
+
+class VariableBCDescriptor
+{
+ private:
+  std::shared_ptr<const DiscreteFunctionVariant> m_discrete_function_variant;
+  std::vector<std::shared_ptr<const IBoundaryConditionDescriptor>> m_bc_descriptor_list;
+
+ public:
+  const std::shared_ptr<const DiscreteFunctionVariant>&
+  discreteFunctionVariant() const
+  {
+    return m_discrete_function_variant;
+  }
+
+  const std::vector<std::shared_ptr<const IBoundaryConditionDescriptor>>&
+  bcDescriptorList() const
+  {
+    return m_bc_descriptor_list;
+  }
+
+  VariableBCDescriptor(const std::shared_ptr<const DiscreteFunctionVariant>& discrete_function_variant,
+                       const std::vector<std::shared_ptr<const IBoundaryConditionDescriptor>>& bc_descriptor_list)
+    : m_discrete_function_variant{discrete_function_variant}, m_bc_descriptor_list{bc_descriptor_list}
+  {}
+
+  VariableBCDescriptor(const VariableBCDescriptor&) = default;
+  VariableBCDescriptor(VariableBCDescriptor&&)      = default;
+
+  VariableBCDescriptor()  = default;
+  ~VariableBCDescriptor() = default;
+};
+
+#endif   // VARIABLE_BC_DESCRIPTOR_HPP