Rename MeshInterpoler -> MeshRelaxer

Also change the language function associated to mesh relaxation:
interpolate -> relax

src/language/modules/MeshModule.cpp

@@ -11,7 +11,7 @@
 #include <mesh/DiamondDualMeshManager.hpp>
 #include <mesh/GmshReader.hpp>
 #include <mesh/Mesh.hpp>
-#include <mesh/MeshInterpoler.hpp>
+#include <mesh/MeshRelaxer.hpp>
 #include <mesh/MeshTransformer.hpp>
 #include <utils/Exceptions.hpp>
 
@@ -42,7 +42,7 @@ MeshModule::MeshModule()
 
                               ));
 
-  this->_addBuiltinFunction("interpolate",
+  this->_addBuiltinFunction("relax",
                             std::make_shared<BuiltinFunctionEmbedder<
                               std::shared_ptr<const IMesh>(const std::shared_ptr<const IMesh>&,
                                                            const std::shared_ptr<const IMesh>&, const double&)>>(
@@ -50,7 +50,7 @@ MeshModule::MeshModule()
                               [](const std::shared_ptr<const IMesh>& source_mesh,
                                  const std::shared_ptr<const IMesh>& destination_mesh,
                                  const double& theta) -> std::shared_ptr<const IMesh> {
-                                return MeshInterpoler{}.interpolate(source_mesh, destination_mesh, theta);
+                                return MeshRelaxer{}.relax(source_mesh, destination_mesh, theta);
                               }
 
                               ));

src/mesh/CMakeLists.txt

@@ -20,7 +20,7 @@ add_library(
   MeshFaceBoundary.cpp
   MeshFlatFaceBoundary.cpp
   MeshFlatNodeBoundary.cpp
-  MeshInterpoler.cpp
+  MeshRelaxer.cpp
   MeshLineNodeBoundary.cpp
   MeshNodeBoundary.cpp
   MeshRandomizer.cpp

src/mesh/MeshInterpoler.hpp

-#ifndef MESH_INTERPOLER_HPP
-#define MESH_INTERPOLER_HPP
-
-class IMesh;
-
-template <typename ConnectivityType>
-class Mesh;
-
-#include <memory>
-
-class MeshInterpoler
-{
- private:
-  template <typename ConnectivityType>
-  std::shared_ptr<const Mesh<ConnectivityType>> _interpolate(const Mesh<ConnectivityType>& source_mesh,
-                                                             const Mesh<ConnectivityType>& destination_mesh,
-                                                             const double& theta) const;
-
- public:
-  std::shared_ptr<const IMesh> interpolate(const std::shared_ptr<const IMesh>& p_source_mesh,
-                                           const std::shared_ptr<const IMesh>& p_destination_mesh,
-                                           const double& theta) const;
-  MeshInterpoler()  = default;
-  ~MeshInterpoler() = default;
-};
-
-#endif   // MESH_INTERPOLER_HPP

src/mesh/MeshInterpoler.cpp → src/mesh/MeshRelaxer.cpp

-#include <mesh/MeshInterpoler.hpp>
+#include <mesh/MeshRelaxer.hpp>
 
 #include <mesh/Connectivity.hpp>
 #include <mesh/Mesh.hpp>
 
 template <typename ConnectivityType>
 std::shared_ptr<const Mesh<ConnectivityType>>
-MeshInterpoler::_interpolate(const Mesh<ConnectivityType>& source_mesh,
+MeshRelaxer::_relax(const Mesh<ConnectivityType>& source_mesh,
                     const Mesh<ConnectivityType>& destination_mesh,
                     const double& theta) const
 {
@@ -23,12 +23,12 @@ MeshInterpoler::_interpolate(const Mesh<ConnectivityType>& source_mesh,
 
     return std::make_shared<Mesh<ConnectivityType>>(source_mesh.shared_connectivity(), theta_xr);
   } else {
-    throw NormalError("interpolated meshes must share the same connectivity");
+    throw NormalError("relaxed meshes must share the same connectivity");
   }
 }
 
 std::shared_ptr<const IMesh>
-MeshInterpoler::interpolate(const std::shared_ptr<const IMesh>& p_source_mesh,
+MeshRelaxer::relax(const std::shared_ptr<const IMesh>& p_source_mesh,
                    const std::shared_ptr<const IMesh>& p_destination_mesh,
                    const double& theta) const
 {
@@ -38,17 +38,17 @@ MeshInterpoler::interpolate(const std::shared_ptr<const IMesh>& p_source_mesh,
     switch (p_source_mesh->dimension()) {
     case 1: {
       using MeshType = Mesh<Connectivity<1>>;
-      return this->_interpolate(dynamic_cast<const MeshType&>(*p_source_mesh),
+      return this->_relax(dynamic_cast<const MeshType&>(*p_source_mesh),
                           dynamic_cast<const MeshType&>(*p_destination_mesh), theta);
     }
     case 2: {
       using MeshType = Mesh<Connectivity<2>>;
-      return this->_interpolate(dynamic_cast<const MeshType&>(*p_source_mesh),
+      return this->_relax(dynamic_cast<const MeshType&>(*p_source_mesh),
                           dynamic_cast<const MeshType&>(*p_destination_mesh), theta);
     }
     case 3: {
       using MeshType = Mesh<Connectivity<3>>;
-      return this->_interpolate(dynamic_cast<const MeshType&>(*p_source_mesh),
+      return this->_relax(dynamic_cast<const MeshType&>(*p_source_mesh),
                           dynamic_cast<const MeshType&>(*p_destination_mesh), theta);
     }
     default: {

src/mesh/MeshRelaxer.hpp

+#ifndef MESH_RELAXER_HPP
+#define MESH_RELAXER_HPP
+
+class IMesh;
+
+template <typename ConnectivityType>
+class Mesh;
+
+#include <memory>
+
+class MeshRelaxer
+{
+ private:
+  template <typename ConnectivityType>
+  std::shared_ptr<const Mesh<ConnectivityType>> _relax(const Mesh<ConnectivityType>& source_mesh,
+                                                       const Mesh<ConnectivityType>& destination_mesh,
+                                                       const double& theta) const;
+
+ public:
+  std::shared_ptr<const IMesh> relax(const std::shared_ptr<const IMesh>& p_source_mesh,
+                                     const std::shared_ptr<const IMesh>& p_destination_mesh,
+                                     const double& theta) const;
+  MeshRelaxer()  = default;
+  ~MeshRelaxer() = default;
+};
+
+#endif   // MESH_RELAXER_HPP