fixup! coupling module

src/language/modules/CouplageModule.cpp

 #include <language/modules/CouplageModule.hpp>
 
-// #include <analysis/GaussLegendreQuadratureDescriptor.hpp>
-// #include <analysis/GaussLobattoQuadratureDescriptor.hpp>
-// #include <analysis/GaussQuadratureDescriptor.hpp>
-// #include <language/algorithms/ElasticityDiamondAlgorithm.hpp>
-// #include <language/algorithms/Heat5PointsAlgorithm.hpp>
-// #include <language/algorithms/HeatDiamondAlgorithm.hpp>
-// #include <language/algorithms/HeatDiamondAlgorithm2.hpp>
-// #include <language/algorithms/ParabolicHeat.hpp>
-// #include <language/algorithms/UnsteadyElasticity.hpp>
-// #include <language/modules/BinaryOperatorRegisterForVh.hpp>
-// #include <language/modules/MathFunctionRegisterForVh.hpp>
-// #include <language/modules/UnaryOperatorRegisterForVh.hpp>
-#include <language/utils/BinaryOperatorProcessorBuilder.hpp>
+#include <language/modules/MeshModule.hpp>
 #include <language/utils/BuiltinFunctionEmbedder.hpp>
-#include <mesh/Mesh.hpp>
-// #include <mesh/MeshData.hpp>
-// #include <mesh/MeshDataManager.hpp>
-// #include <language/utils/TypeDescriptor.hpp>
-// #include <utils/Socket.hpp>
-
+#include <language/utils/SymbolTable.hpp>
+#include <language/utils/TypeDescriptor.hpp>
 #include <memory>
+#include <mesh/Connectivity.hpp>
+#include <mesh/Mesh.hpp>
+#include <utils/CommunicatorManager.hpp>
+#include <utils/Messenger.hpp>
+#ifdef PUGS_HAS_MPI
+#include <mpi.h>
+#endif   // PUGS_HAS_MPI
 
 CouplageModule::CouplageModule()
 {
-  // this->_addBuiltinFunction("blabla", std::make_shared<BuiltinFunctionEmbedder<std::string()>>(
-
-  //                                       []() -> std::string { return "blabla"; }
-
-  //                                       ));
   this->_addBuiltinFunction("blabla", std::function(
 
                                         []() -> std::string { return "blabla"; }
@@ -43,10 +29,31 @@ CouplageModule::CouplageModule()
                                       ));
   this->_addBuiltinFunction("test", std::function(
 
-                                      [](std::shared_ptr<const IMesh> p_mesh) -> void {
-                                        auto dim = p_mesh->dimension();
-                                        std::cout << "in test: " << dim << std::endl;
-                                        // getInstance()test();
+                                      [](const std::shared_ptr<const IMesh>& i_mesh) -> void {
+                                        /* this->test(); */
+
+                                        auto dim = i_mesh->dimension();
+                                        std::cout << "in test dim: " << dim << std::endl;
+                                        using MeshType = Mesh<Connectivity<2>>;
+
+                                        std::shared_ptr p_mesh = std::dynamic_pointer_cast<const MeshType>(i_mesh);
+                                        auto nNodes            = p_mesh->numberOfNodes();
+                                        std::cout << "n nodes: " << nNodes << std::endl;
+                                        auto nCells = p_mesh->numberOfCells();
+                                        std::cout << "n cells: " << nCells << std::endl;
+                                        auto nEdges = p_mesh->numberOfEdges();
+                                        std::cout << "n edges: " << nEdges << std::endl;
+                                        auto nFaces = p_mesh->numberOfFaces();
+                                        std::cout << "n faces: " << nFaces << std::endl;
+                                        const auto nodes = p_mesh->xr();
+                                        if (CommunicatorManager::hasSplitColor()) {
+                                          std::cout << "\033[01;31m"
+                                                    << "COUPLED"
+                                                    << "\033[00;00m" << std::endl;
+
+                                          auto COMM_WORLD = parallel::Messenger::getInstance().globalComm();
+                                          auto COMM_LOCAL = parallel::Messenger::getInstance().comm();
+                                        }
                                       }
 
                                       ));

src/language/modules/CouplageModule.hpp

@@ -2,6 +2,8 @@
 #define COUPLAGE_MODULE_HPP
 
 #include <language/modules/BuiltinModule.hpp>
+#include <language/utils/ASTNodeDataTypeTraits.hpp>
+#include <utils/PugsMacros.hpp>
 
 // class IBoundaryDescriptor;
 // template <>

src/language/modules/ModuleRepository.cpp

@@ -55,6 +55,7 @@ ModuleRepository::_subscribe(std::unique_ptr<IModule> m)
 ModuleRepository::ModuleRepository()
 {
   this->_subscribe(std::make_unique<CoreModule>());
+  this->_subscribe(std::make_unique<CouplageModule>());
   this->_subscribe(std::make_unique<LinearSolverModule>());
   this->_subscribe(std::make_unique<MathModule>());
   this->_subscribe(std::make_unique<MeshModule>());

src/utils/Messenger.hpp

@@ -456,6 +456,13 @@ class Messenger
   {
     return m_pugs_comm_world;
   }
+
+  PUGS_INLINE
+  const MPI_Comm&
+  globalComm() const
+  {
+    return MPI_COMM_WORLD;
+  }
 #endif   // PUGS_HAS_MPI
 
   void barrier() const;