feat: print MPI - wrapper fmt and explicit control of redirection

.gitignore

@@ -9,6 +9,11 @@ __pycache__
 .cache
 *.old
 
+# Editor swap files
+*.swp
+*.swo
+*.swn
+
 # Created by https://www.toptal.com/developers/gitignore/api/cmake,linux,macos,visualstudiocode,python
 # Edit at https://www.toptal.com/developers/gitignore?templates=cmake,linux,macos,visualstudiocode,python
 

demos/FiniteVolume/AMR_Burgers_Hat.cpp

@@ -12,6 +12,7 @@
 #include <samurai/field.hpp>
 #include <samurai/io/hdf5.hpp>
 #include <samurai/io/restart.hpp>
+#include <samurai/print.hpp>
 #include <samurai/samurai.hpp>
 
 #include "stencil_field.hpp"
@@ -263,7 +264,7 @@ int main(int argc, char* argv[])
         std::size_t ite_adapt = 0;
         while (true)
         {
-            std::cout << "\tmesh adaptation: " << ite_adapt++ << std::endl;
+            samurai::io::print("mesh adaptation: {}\n", ite_adapt++);
             samurai::update_ghost(phi);
             tag.resize();
             AMR_criteria(phi, tag);
@@ -281,7 +282,7 @@ int main(int argc, char* argv[])
             t = Tf;
         }
 
-        std::cout << fmt::format("iteration {}: t = {}, dt = {}", nt++, t, dt) << std::endl;
+        samurai::io::print(samurai::io::root, "iteration {}: t = {}, dt = {}\n", nt++, t, dt);
 
         // Numerical scheme
         samurai::update_ghost(phi);

demos/FiniteVolume/BZ/bz_2d.cpp

@@ -9,6 +9,7 @@
 #include <samurai/io/hdf5.hpp>
 #include <samurai/mr/adapt.hpp>
 #include <samurai/mr/mesh.hpp>
+#include <samurai/print.hpp>
 #include <samurai/stencil_field.hpp>
 
 #include "../../LBM/boundary_conditions.hpp"
@@ -313,7 +314,7 @@ int main()
 
     while (t < Tf)
     {
-        fmt::print(fmt::format("Iteration = {:4d}, t: {}\n", nb_ite, t));
+        samurai::io::print(samurai::io::root, "{}", fmt::format("Iteration = {:4d}, t: {}\n", nb_ite, t));
 
         if (max_level > min_level)
         {
@@ -323,20 +324,20 @@ int main()
         tic();
         reaction(field, t, t + .5 * dt);
         auto duration = toc();
-        fmt::print(fmt::format("first reaction: {}\n", duration));
+        samurai::io::print("{}", fmt::format("first reaction: {}\n", duration));
 
         tic();
         RK4(field, dt, std::ceil(dt / dt_diffusion), update_bc, D_b, D_c);
         duration = toc();
-        fmt::print(fmt::format("diffusion: {}\n", duration));
+        samurai::io::print("{}", fmt::format("diffusion: {}\n", duration));
         /*
         rock4_integration(double tini, double tend, int neq, double *u,
                     func_rock fcn, double tol, int *info)
         */
         tic();
         reaction(field, t + .5 * dt, t + dt);
         duration = toc();
-        fmt::print(fmt::format("second reaction: {}\n", duration));
+        samurai::io::print("{}", fmt::format("second reaction: {}\n", duration));
 
         if (nsave == 20)
         {

demos/FiniteVolume/BZ/bz_2d_AMR.cpp

@@ -10,6 +10,7 @@
 #include <samurai/mr/operators.hpp>
 #include <samurai/numeric/prediction.hpp>
 #include <samurai/numeric/projection.hpp>
+#include <samurai/print.hpp>
 #include <samurai/static_algorithm.hpp>
 #include <samurai/stencil_field.hpp>
 
@@ -691,7 +692,7 @@ int main()
 
     while (t < Tf)
     {
-        fmt::print(fmt::format("Iteration = {:4d}, t: {}\n", nb_ite, t));
+        samurai::io::print(samurai::io::root, "{}", fmt::format("Iteration = {:4d}, t: {}\n", nb_ite, t));
 
         std::size_t idx = 0;
 
@@ -710,20 +711,20 @@ int main()
         tic();
         reaction(field, t, t + .5 * dt);
         auto duration = toc();
-        fmt::print(fmt::format("first reaction: {}\n", duration));
+        samurai::io::print("{}", fmt::format("first reaction: {}\n", duration));
 
         tic();
         RK4(field, dt, std::ceil(dt / dt_diffusion), update_bc_for_level, D_b, D_c);
         duration = toc();
-        fmt::print(fmt::format("diffusion: {}\n", duration));
+        samurai::io::print("{}", fmt::format("diffusion: {}\n", duration));
         /*
         rock4_integration(double tini, double tend, int neq, double *u,
                     func_rock fcn, double tol, int *info)
         */
         tic();
         reaction(field, t + .5 * dt, t + dt);
         duration = toc();
-        fmt::print(fmt::format("second reaction: {}\n", duration));
+        samurai::io::print("{}", fmt::format("second reaction: {}\n", duration));
 
         if (nsave == 20)
         {

demos/FiniteVolume/advection_1d.cpp

@@ -140,7 +140,7 @@ int main(int argc, char* argv[])
             t = Tf;
         }
 
-        std::cout << fmt::format("iteration {}: t = {}, dt = {}", nt++, t, dt) << std::endl;
+        samurai::io::print(samurai::io::root, "iteration {}: t = {}, dt = {}\n", nt++, t, dt);
 
         samurai::update_ghost_mr(u);
         unp1.resize();

demos/FiniteVolume/advection_2d.cpp

@@ -133,7 +133,7 @@ int main(int argc, char* argv[])
             t = Tf;
         }
 
-        std::cout << fmt::format("iteration {}: t = {}, dt = {}", nt++, t, dt) << std::endl;
+        samurai::io::print(samurai::io::root, "iteration {}: t = {}, dt = {}\n", nt++, t, dt);
 
         samurai::update_ghost_mr(u);
         unp1.resize();

demos/FiniteVolume/advection_2d_user_bc.cpp

@@ -165,7 +165,7 @@ int main(int argc, char* argv[])
             t = Tf;
         }
 
-        std::cout << fmt::format("iteration {}: t = {}, dt = {}", nt++, t, dt) << std::endl;
+        samurai::io::print(samurai::io::root, "iteration {}: t = {}, dt = {}\n", nt++, t, dt);
 
         samurai::update_ghost_mr(u);
         unp1.resize();

demos/FiniteVolume/burgers.cpp

@@ -55,7 +55,7 @@ int main_dim(int argc, char* argv[])
     using Box     = samurai::Box<double, dim>;
     using point_t = typename Box::point_t;
 
-    std::cout << "------------------------- Burgers -------------------------" << std::endl;
+    samurai::io::print("------------------------- Burgers -------------------------\n");
 
     //--------------------//
     // Program parameters //
@@ -176,7 +176,7 @@ int main_dim(int argc, char* argv[])
         }
         else
         {
-            std::cerr << "Unmanaged initial solution '" << init_sol << "'.";
+            samurai::io::eprint("Unmanaged initial solution '{}' .\n", init_sol);
             return EXIT_FAILURE;
         }
     }
@@ -244,7 +244,7 @@ int main_dim(int argc, char* argv[])
             dt += Tf - t;
             t = Tf;
         }
-        std::cout << fmt::format("iteration {}: t = {:.2f}, dt = {}", nt++, t, dt) << std::flush;
+        samurai::io::print(samurai::io::root, "{}", fmt::format("iteration {}: t = {:.2f}, dt = {}", nt++, t, dt));
 
         // Mesh adaptation
         MRadaptation(mra_config);
@@ -286,7 +286,7 @@ int main_dim(int argc, char* argv[])
                                              {
                                                  return exact_solution<n_comp>(coord, t);
                                              });
-            std::cout << ", L2-error: " << std::scientific << std::setprecision(2) << error;
+            samurai::io::print(", L2-error: {:.2e}", error);
 
             if (mesh.min_level() != mesh.max_level())
             {
@@ -297,19 +297,18 @@ int main_dim(int argc, char* argv[])
                                           {
                                               return exact_solution<n_comp>(coord, t);
                                           });
-                std::cout << ", L2-error (recons): " << std::scientific << std::setprecision(2) << error;
+                samurai::io::print(", L2-error (recons): {:.2e}", error);
             }
         }
 
-        std::cout << std::endl;
+        samurai::io::print("\n");
     }
 
     if constexpr (dim == 1)
     {
-        std::cout << std::endl;
-        std::cout << "Run the following command to view the results:" << std::endl;
-        std::cout << "python <<path to samurai>>/python/read_mesh.py " << filename << "_ite_ --field u level --start 0 --end " << nsave
-                  << std::endl;
+        samurai::io::print("\n");
+        samurai::io::print("Run the following command to view the results:\n");
+        samurai::io::print("python <<path to samurai>>/python/read_mesh.py {}_ite_ --field u level --start 0 --end {}\n", filename, nsave);
     }
 
     samurai::finalize();

demos/FiniteVolume/burgers_mra.cpp

@@ -82,7 +82,7 @@ void run_simulation(Field& u,
 {
     auto& mesh = u.mesh();
 
-    std::cout << std::endl << "max-level-flux enabled: " << scheme.enable_max_level_flux() << std::endl;
+    samurai::io::print("\nmax-level-flux enabled: {}\n", scheme.enable_max_level_flux());
 
     if (scheme.enable_max_level_flux())
     {
@@ -162,7 +162,7 @@ void run_simulation(Field& u,
             dt += Tf - t;
             t = Tf;
         }
-        std::cout << fmt::format("iteration {}: t = {:.2f}, dt = {}", nt++, t, dt) << std::flush;
+        samurai::io::print(samurai::io::root, "iteration {}: t = {:.2f}, dt = {}\n", nt++, t, dt);
 
         // Mesh adaptation
         MRadaptation(mra_config);
@@ -179,23 +179,22 @@ void run_simulation(Field& u,
         auto u_recons = samurai::reconstruction(u);
 
         // Error
-        std::cout << ", L2-error: " << std::scientific;
-        std::cout.precision(2);
+        samurai::io::print(", L2-error: ");
         if (init_sol == "hat")
         {
             double error = samurai::L2_error(u,
                                              [&](const auto& coord)
                                              {
                                                  return hat_exact_solution(coord[0], t);
                                              });
-            std::cout << "[w.r.t. exact, no recons] " << error;
+            samurai::io::print("[w.r.t. exact, no recons] {}", error);
 
             error = samurai::L2_error(u_recons,
                                       [&](const auto& coord)
                                       {
                                           return hat_exact_solution(coord[0], t);
                                       });
-            std::cout << ", [w.r.t. exact, recons] " << error;
+            samurai::io::print(", [w.r.t. exact, recons] {}", error);
         }
 
         double error = 0;
@@ -206,7 +205,7 @@ void run_simulation(Field& u,
                                    error += std::pow(u_max[cell] - u_recons[cell2], 2) * std::pow(cell.length, 1);
                                });
         error = std::sqrt(error);
-        std::cout << ", [w.r.t. max level, recons] " << error;
+        samurai::io::print(", [w.r.t. max level, recons] {}", error);
 
         // Save the result
         if (t >= static_cast<double>(nsave) * dt_save || t == Tf)
@@ -219,7 +218,7 @@ void run_simulation(Field& u,
             nsave++;
         }
 
-        std::cout << std::endl;
+        samurai::io::print("\n");
     }
 }
 
@@ -230,7 +229,7 @@ int main(int argc, char* argv[])
 
     auto& app = samurai::initialize("Finite volume example for the Burgers equation in 1d", argc, argv);
 
-    std::cout << "------------------------- Burgers -------------------------" << std::endl;
+    samurai::io::print("------------------------- Burgers -------------------------\n");
 
     //--------------------//
     // Program parameters //
@@ -296,12 +295,12 @@ int main(int argc, char* argv[])
     scheme.enable_max_level_flux(true);
     run_simulation(u, unp1, u_max, unp1_max, scheme, cfl, mra_config, init_sol, nfiles, path, filename, nsave);
 
-    std::cout << std::endl;
-    std::cout << "Run the following commands to view the results:" << std::endl;
-    std::cout << "max-level-flux disabled:" << std::endl;
-    std::cout << "     python ../python/read_mesh.py " << filename << "_recons_ite_ --field u --start 0 --end " << nsave << std::endl;
-    std::cout << "max-level-flux enabled:" << std::endl;
-    std::cout << "     python ../python/read_mesh.py " << filename << "_mlf_recons_ite_ --field u --start 0 --end " << nsave << std::endl;
+    samurai::io::print("\n");
+    samurai::io::print("Run the following commands to view the results:\n");
+    samurai::io::print("max-level-flux disabled:\n");
+    samurai::io::print("     python ../python/read_mesh.py {}_recons_ite_ --field u --start 0 --end {}\n", filename, nsave);
+    samurai::io::print("max-level-flux enabled:\n");
+    samurai::io::print("     python ../python/read_mesh.py {}_mlf_recons_ite_ --field u --start 0 --end {}\n", filename, nsave);
 
     samurai::finalize();
     return 0;

demos/FiniteVolume/burgers_os.cpp

@@ -12,6 +12,7 @@
 namespace fs = std::filesystem;
 
 #include <numbers>
+#include <xtensor/io/xio.hpp>
 
 #include "convection_nonlin_os.hpp"
 
@@ -51,7 +52,7 @@ void check_diff(auto& field, auto& lca_left, auto& lca_right)
             set(
                 [&](auto& i, auto)
                 {
-                    std::cout << "Difference found !! " << level << " " << i << "\n";
+                    samurai::io::print("Difference found !! {} {}\n", level, i);
                     auto level_ = samurai::make_scalar_field<std::size_t>("level", mesh);
                     samurai::for_each_cell(mesh,
                                            [&](const auto& cell)
@@ -67,11 +68,11 @@ void check_diff(auto& field, auto& lca_left, auto& lca_right)
                 {
                     if (xt::any(xt::abs(field(level, i) - field(level, i + (1 << level))) > 1e-13))
                     {
-                        std::cout << fmt::format("\nDifference found at level {} on interval {}:\n", level, i);
-                        std::cout << fmt::format("\tleft = {}\n", field(level, i));
-                        std::cout << fmt::format("\tright = {}\n", field(level, i + (1 << level)));
-                        std::cout << fmt::format("\terror = {}\n", xt::abs(field(level, i) - field(level, i + (1 << level))));
-                        std::cout << mesh << std::endl;
+                        samurai::io::print("\nDifference found at level {} on interval {}:\n", level, i);
+                        samurai::io::print("\tleft = {}\n", fmt::streamed(field(level, i)));
+                        samurai::io::print("\tright = {}\n", fmt::streamed(field(level, i + (1 << level))));
+                        samurai::io::print("\terror = {}\n", fmt::streamed(xt::abs(field(level, i) - field(level, i + (1 << level)))));
+                        samurai::io::print("{}\n", fmt::streamed(mesh));
                         auto level_ = samurai::make_scalar_field<std::size_t>("level", mesh);
                         samurai::for_each_cell(mesh,
                                                [&](const auto& cell)
@@ -94,7 +95,7 @@ int main(int argc, char* argv[])
     using Box     = samurai::Box<double, dim>;
     using point_t = typename Box::point_t;
 
-    std::cout << "------------------------- Burgers 1D -------------------------" << std::endl;
+    samurai::io::print("------------------------- Burgers 1D -------------------------\n");
 
     //--------------------//
     // Program parameters //
@@ -132,6 +133,8 @@ int main(int argc, char* argv[])
 
     SAMURAI_PARSE(argc, argv);
 
+    samurai::io::print("  max_level = {}   min_level = {}\n", max_level, min_level);
+
     //--------------------//
     // Problem definition //
     //--------------------//
@@ -200,7 +203,7 @@ int main(int argc, char* argv[])
             dt += Tf - t;
             t = Tf;
         }
-        std::cout << fmt::format("iteration {}: t = {:.12f}, dt = {}", nt++, t, dt) << std::flush;
+        samurai::io::print(samurai::io::root, "{}", fmt::format("iteration {}: t = {:.12f}, dt = {}", nt++, t, dt));
 
         // Mesh adaptation
         MRadaptation(mra_config);
@@ -211,7 +214,7 @@ int main(int argc, char* argv[])
         }
         catch (...)
         {
-            std::cout << "Exception caught in check_diff after adaptation" << std::endl;
+            samurai::io::print("Exception caught in check_diff after adaptation\n");
             samurai::finalize();
             return 1;
         }
@@ -229,21 +232,21 @@ int main(int argc, char* argv[])
         }
         catch (...)
         {
-            std::cout << "Exception caught in check_diff after integration" << std::endl;
+            samurai::io::print("Exception caught in check_diff after integration\n");
             samurai::finalize();
             return 1;
         }
 
         // Save the result
         if (nfiles == 0 || t >= static_cast<double>(nsave) * dt_save || t == Tf)
         {
-            std::cout << "  (saving results)" << std::flush;
+            samurai::io::print("  (saving results)");
             std::string suffix = (nfiles != 1) ? fmt::format("_level_{}_{}_ite_{}", min_level, max_level, nsave) : "";
             save(path, filename, u, suffix);
             nsave++;
         }
 
-        std::cout << std::endl;
+        samurai::io::print("\n");
     }
 
     samurai::finalize();