Remove the constructors based on FunctionSymbolId

These constructors existence was the result of a bad design and just
treated very special cases

src/scheme/AcousticSolver.cpp

 #include <scheme/AcousticSolver.hpp>
 
+#include <language/utils/InterpolateItemValue.hpp>
 #include <mesh/ItemValueUtils.hpp>
 #include <mesh/MeshNodeBoundary.hpp>
 #include <scheme/DirichletBoundaryConditionDescriptor.hpp>

src/scheme/DiscreteFunctionInterpoler.cpp

 #include <scheme/DiscreteFunctionInterpoler.hpp>
 
+#include <language/utils/InterpolateItemValue.hpp>
 #include <scheme/DiscreteFunctionP0.hpp>
 #include <utils/Exceptions.hpp>
 
@@ -8,7 +9,13 @@ std::shared_ptr<IDiscreteFunction>
 DiscreteFunctionInterpoler::_interpolate() const
 {
   std::shared_ptr mesh    = std::dynamic_pointer_cast<const Mesh<Connectivity<Dimension>>>(m_mesh);
-  return std::make_shared<DiscreteFunctionP0<Dimension, DataType>>(mesh, m_function_id);
+  using MeshDataType      = MeshData<Dimension>;
+  MeshDataType& mesh_data = MeshDataManager::instance().getMeshData(*mesh);
+
+  return std::make_shared<
+    DiscreteFunctionP0<Dimension, DataType>>(mesh,
+                                             InterpolateItemValue<DataType(TinyVector<Dimension>)>::
+                                               template interpolate<ItemType::cell>(m_function_id, mesh_data.xj()));
 }
 
 template <size_t Dimension>

src/scheme/DiscreteFunctionP0.hpp

@@ -3,7 +3,6 @@
 
 #include <scheme/IDiscreteFunction.hpp>
 
-#include <language/utils/InterpolateItemValue.hpp>
 #include <mesh/Connectivity.hpp>
 #include <mesh/Mesh.hpp>
 #include <mesh/MeshData.hpp>
@@ -246,16 +245,6 @@ class DiscreteFunctionP0 : public IDiscreteFunction
     return ratio;
   }
 
-  DiscreteFunctionP0(const std::shared_ptr<const MeshType>& mesh, const FunctionSymbolId& function_id) : m_mesh(mesh)
-  {
-    using MeshDataType      = MeshData<Dimension>;
-    MeshDataType& mesh_data = MeshDataManager::instance().getMeshData(*mesh);
-
-    m_cell_values =
-      InterpolateItemValue<DataType(TinyVector<Dimension>)>::template interpolate<ItemType::cell>(function_id,
-                                                                                                  mesh_data.xj());
-  }
-
   DiscreteFunctionP0(const std::shared_ptr<const MeshType>& mesh) : m_mesh{mesh}, m_cell_values{mesh->connectivity()} {}
 
   DiscreteFunctionP0(const std::shared_ptr<const MeshType>& mesh, const CellValue<DataType>& cell_value)

src/scheme/DiscreteFunctionP0Vector.hpp

@@ -3,7 +3,6 @@
 
 #include <scheme/IDiscreteFunction.hpp>
 
-#include <language/utils/InterpolateItemArray.hpp>
 #include <mesh/Connectivity.hpp>
 #include <mesh/ItemArray.hpp>
 #include <mesh/Mesh.hpp>
@@ -195,17 +194,6 @@ class DiscreteFunctionP0Vector : public IDiscreteFunction
     return product;
   }
 
-  DiscreteFunctionP0Vector(const std::shared_ptr<const MeshType>& mesh,
-                           const std::vector<FunctionSymbolId>& function_symbol_id_list)
-    : m_mesh(mesh)
-  {
-    using MeshDataType      = MeshData<Dimension>;
-    MeshDataType& mesh_data = MeshDataManager::instance().getMeshData(*mesh);
-
-    m_cell_arrays = InterpolateItemArray<DataType(
-      TinyVector<Dimension>)>::template interpolate<ItemType::cell>(function_symbol_id_list, mesh_data.xj());
-  }
-
   DiscreteFunctionP0Vector(const std::shared_ptr<const MeshType>& mesh, size_t size)
     : m_mesh{mesh}, m_cell_arrays{mesh->connectivity(), size}
   {}

src/scheme/DiscreteFunctionVectorInterpoler.cpp

 #include <scheme/DiscreteFunctionVectorInterpoler.hpp>
 
+#include <language/utils/InterpolateItemArray.hpp>
 #include <scheme/DiscreteFunctionP0Vector.hpp>
 #include <utils/Exceptions.hpp>
 
@@ -8,7 +9,14 @@ std::shared_ptr<IDiscreteFunction>
 DiscreteFunctionVectorInterpoler::_interpolate() const
 {
   std::shared_ptr mesh = std::dynamic_pointer_cast<const Mesh<Connectivity<Dimension>>>(m_mesh);
-  return std::make_shared<DiscreteFunctionP0Vector<Dimension, DataType>>(mesh, m_function_id_list);
+
+  using MeshDataType      = MeshData<Dimension>;
+  MeshDataType& mesh_data = MeshDataManager::instance().getMeshData(*mesh);
+
+  return std::make_shared<
+    DiscreteFunctionP0Vector<Dimension, DataType>>(mesh, InterpolateItemArray<DataType(TinyVector<Dimension>)>::
+                                                           template interpolate<ItemType::cell>(m_function_id_list,
+                                                                                                mesh_data.xj()));
 }
 
 template <size_t Dimension>