PipelineGraph.cpp

Go to the documentation of this file.

/**
 * @file PipelineGraph.cpp
 * @brief Plot pipeline graph
 * @version 0.1
 * @date 2025-12-26
 * 
 * @copyright Copyright (c) 2025
 * 
 */
 
#include <MoFEM.hpp>
 
#include <boost/graph/adjacency_list.hpp>
#include <boost/graph/graphviz.hpp>
#include <tuple>
 
struct VertexData {
  std::string label;
  std::string shape;
  std::string style;
  std::string color;
};
 
using Graph =
    boost::adjacency_list<boost::vecS, boost::vecS, boost::directedS,
                          boost::property<boost::vertex_name_t, VertexData>,
                          boost::property<boost::edge_name_t, std::string>>;
 
namespace MoFEM {
 
using UserDataOperator = ForcesAndSourcesCore::UserDataOperator;
using VertexDescriptor = boost::graph_traits<Graph>::vertex_descriptor;
 
static VertexDescriptor
plot_pipeline_graph_impl(const boost::ptr_deque<UserDataOperator> &pip,
                      std::string pip_name, boost::shared_ptr<Graph> g_ptr,
                      VertexDescriptor root_vertex) {
 
  auto get_fe_name = [](const auto &fe) {
    std::ostringstream ss;
    ss << "FE:" << boost::typeindex::type_id_runtime(fe).pretty_name();
    return ss;
  };
 
  auto get_name_short = [](const auto &op) {
    std::ostringstream ss;
    ss << "OP:" << boost::typeindex::type_id_runtime(op).pretty_name();
    return ss;
  };
 
  auto get_name_long = [get_name_short](const auto &op) {
    auto ss = get_name_short(op);
    switch (op.getOpType()) {
      case UserDataOperator::OPROW:
      ss << ":r:" << op.rowFieldName;
      break;
      case UserDataOperator::OPCOL:
      ss << ":c:" << op.colFieldName;
      break;
      case UserDataOperator::OPROWCOL:
        ss << ":r:" << op.rowFieldName << ":c:" << op.colFieldName;
        break;
      case UserDataOperator::OPSPACE:
        ss << ":s:" << FieldSpaceNames[op.sPace];
        break;
      default:
        CHK_THROW_MESSAGE(MOFEM_DATA_INCONSISTENCY, "Impossible operator type");
      };
    return ss;
  };
 
  auto &g = *g_ptr;
 
  auto vname = get(boost::vertex_name, g);
  auto ename = get(boost::edge_name, g);
 
 
  std::function<VertexDescriptor(VertexDescriptor &,
                                 const boost::ptr_deque<UserDataOperator> &)>
      add_tree = [&](VertexDescriptor &root_vertex,
                     const boost::ptr_deque<UserDataOperator> &pip) {
        auto prev_vertex = root_vertex;
 
        for (auto &op : pip) {
 
          auto op_vertex = boost::add_vertex(g);
          vname[op_vertex] = {get_name_long(op).str(), "box", "solid",
                              "black"};
 
          auto fe_weak_ptr = op.getSubPipelinePtr();
 
          if (auto fe = fe_weak_ptr.lock()) {
 
            auto fe_vertex = boost::add_vertex(g);
            vname[fe_vertex] = {get_fe_name(*fe).str(), "box3d", "filled", "lightgrey"};
 
            auto last_vertex = add_tree(fe_vertex, fe->getOpPtrVector());
 
            // add edges back and from loop
            auto [e_loop_start, ok1_start] =
                add_edge(op_vertex, fe_vertex, g);
            ename[e_loop_start] = "go to loop";
            auto [e_loop_end, ok1_end] = add_edge(last_vertex, op_vertex, g);
            ename[e_loop_end] = "back from loop";
          }
 
          std::ignore = add_edge(prev_vertex, op_vertex, g);
 
          prev_vertex = op_vertex;
        }
 
        return prev_vertex;
      };
 
  auto pip_vertex = boost::add_vertex(g);
  vname[pip_vertex] = {pip_name, "box3d", "filled", "lightgrey"};
  auto [e_root_pip, ok] = add_edge(root_vertex, pip_vertex, g);
  ename[e_root_pip] = "pipeline";
 
  auto last_vertex = add_tree(pip_vertex, pip);
 
  return last_vertex;
}
 
static void write_graphviz_impl(std::string file_name,
                                boost::shared_ptr<Graph> g_ptr) {
 
  auto &g = *g_ptr;
  std::ofstream ofs(file_name);
 
  // Use a custom vertex writer
  auto vertex_writer = [&g](std::ostream& out, const VertexDescriptor& v) {
    auto vdata = get(boost::vertex_name, g)[v];
    out << "[label=\"" << vdata.label << "\", shape=" << vdata.shape
        << ", style=" << vdata.style << ", color=" << vdata.color << "]";
  };
  
  // Use the existing edge name property
  auto edge_writer = boost::make_label_writer(get(boost::edge_name, g));
  
  boost::write_graphviz(ofs, g, vertex_writer, edge_writer);
 
  
}
 
MoFEMErrorCode PipelineGraph::writeGraphGraphviz(
    std::string file_name, std::string pip_name,
    const boost::ptr_deque<UserDataOperator> &pip) {
  MoFEMFunctionBegin;
  boost::shared_ptr<Graph> g_ptr(new Graph());
  auto vname = get(boost::vertex_name, *g_ptr);
  auto root_vertex = boost::add_vertex(*g_ptr);
  vname[root_vertex] = {"Finite Element Pipeline Graph", "ellipse", "solid",
                        "black"};
  plot_pipeline_graph_impl(pip, pip_name, g_ptr, root_vertex);
  write_graphviz_impl(file_name, g_ptr);
  MoFEMFunctionReturn(0);
};
 
static void add_stages(BasicMethodsSequence &pre, FEMethodsSequence &op,
                       BasicMethodsSequence &post,
                       VertexDescriptor start_vertex,
                       boost::shared_ptr<Graph> g_ptr) {
  boost::ptr_deque<UserDataOperator> null_pip;
  auto vname = get(boost::vertex_name, *g_ptr);
 
  auto get_fe_name = [](const auto &fe) {
    std::ostringstream ss;
    ss << "FE:" << boost::typeindex::type_id_runtime(fe).pretty_name();
    return ss;
  };
 
  auto pre_vertex = boost::add_vertex(*g_ptr);
  vname[pre_vertex] = {"Stage PreProcess", "ellipse", "solid", "black"};
  std::ignore = add_edge(start_vertex, pre_vertex, *g_ptr);
 
  auto prev_vertex = pre_vertex;
  for (auto &bit : pre) {
    auto name = "BM:" + get_fe_name(bit.get()).str();
    prev_vertex = plot_pipeline_graph_impl(null_pip, name, g_ptr, prev_vertex);
  }
 
  auto pro_vertex = boost::add_vertex(*g_ptr);
  vname[pro_vertex] = {"Stage Processs", "ellipse", "solid", "black"};
  std::ignore = add_edge(prev_vertex, pro_vertex, *g_ptr);
 
  prev_vertex = pro_vertex;
  for (auto &lit : op) {
    auto name = lit.first + ":" + get_fe_name(*(lit.second)).str();
    if (auto fe_ptr =
            boost::dynamic_pointer_cast<ForcesAndSourcesCore>(lit.second)) {
      prev_vertex = plot_pipeline_graph_impl(fe_ptr->getOpPtrVector(), name, g_ptr,
                                          prev_vertex);
    } else {
      prev_vertex = plot_pipeline_graph_impl(null_pip, name, g_ptr, prev_vertex);
    }
  }
 
  auto post_vertex = boost::add_vertex(*g_ptr);
  vname[post_vertex] = {"Stage PostProcesss", "ellipse", "solid", "black"};
  std::ignore = add_edge(prev_vertex, post_vertex, *g_ptr);
 
  prev_vertex = post_vertex;
  for (auto &bit : post) {
    auto name = "BM:" + get_fe_name(bit.get()).str();
    prev_vertex = plot_pipeline_graph_impl(null_pip, name, g_ptr, prev_vertex);
  }
}
 
MoFEMErrorCode
PipelineGraph::writeKSPGraphGraphviz(KspCtx *ksp_ctx,
                                            std::string file_name) {
  MoFEMFunctionBegin;
  boost::shared_ptr<Graph> g_ptr(new Graph());
  auto &g = *g_ptr;
 
  auto vname = get(boost::vertex_name, g);
 
  auto root_vertex = boost::add_vertex(g);
  vname[root_vertex] = {"KSP Graph", "ellipse", "solid", "black"};
 
  auto lhs_vertex = boost::add_vertex(g);
  vname[lhs_vertex] = {"Lhs", "box3d", "filled", "lightgrey"};
  add_edge(root_vertex, lhs_vertex, g);
  add_stages(ksp_ctx->getPreProcSetOperators(), ksp_ctx->getSetOperators(),
             ksp_ctx->getPostProcSetOperators(), lhs_vertex, g_ptr);
 
  auto rhs_vertex = boost::add_vertex(g);
  vname[rhs_vertex] = {"Rhs", "box3d", "filled", "lightgrey"};
  add_edge(root_vertex, rhs_vertex, g);
  add_stages(ksp_ctx->getPreProcComputeRhs(), ksp_ctx->getComputeRhs(),
             ksp_ctx->getPostProcComputeRhs(), rhs_vertex, g_ptr);
 
  write_graphviz_impl(file_name, g_ptr);
  MoFEMFunctionReturn(0);
}
 
MoFEMErrorCode
PipelineGraph::writeSNESGraphGraphviz(SnesCtx *snes_ctx,
                                             std::string file_name) {
  MoFEMFunctionBegin;
  boost::shared_ptr<Graph> g_ptr(new Graph());
  auto &g = *g_ptr;
 
  auto vname = get(boost::vertex_name, g);
 
  auto root_vertex = boost::add_vertex(g);
  vname[root_vertex] = {"SNES Graph", "ellipse", "solid", "black"};
 
  auto lhs_vertex = boost::add_vertex(g);
  vname[lhs_vertex] = {"Lhs", "box3d", "filled", "lightgrey"};
  add_edge(root_vertex, lhs_vertex, g);
  add_stages(snes_ctx->getPreProcSetOperators(), snes_ctx->getSetOperators(),
             snes_ctx->getPostProcSetOperators(), lhs_vertex, g_ptr);
 
  auto rhs_vertex = boost::add_vertex(g);
  vname[rhs_vertex] = {"Rhs", "box3d", "filled", "lightgrey"};
  add_edge(root_vertex, rhs_vertex, g);
  add_stages(snes_ctx->getPreProcComputeRhs(), snes_ctx->getComputeRhs(),
             snes_ctx->getPostProcComputeRhs(), rhs_vertex, g_ptr);
 
  auto load_vertex = boost::add_vertex(g);
  vname[load_vertex] = {"LoadTangent", "box3d", "filled", "lightgrey"};
  add_edge(root_vertex, load_vertex, g);
  add_stages(snes_ctx->getPreProcLoadTangent(), snes_ctx->getLoadTangent(),
             snes_ctx->getPostProcLoadTangent(), load_vertex, g_ptr);
 
  write_graphviz_impl(file_name, g_ptr);
 
  MoFEMFunctionReturn(0);
}
 
MoFEMErrorCode
PipelineGraph::writeTSGraphGraphviz(TsCtx *ts_ctx,
                                           std::string file_name) {
  MoFEMFunctionBegin;
  boost::shared_ptr<Graph> g_ptr(new Graph());
  auto &g = *g_ptr;
 
  auto vname = get(boost::vertex_name, g);
 
  auto root_vertex = boost::add_vertex(g);
  vname[root_vertex] = {"TS Graph", "ellipse", "solid", "black"};
 
  auto ifunction_vertex = boost::add_vertex(g);
  vname[ifunction_vertex] = {"IFunction", "box3d", "filled", "lightgrey"};
  add_edge(root_vertex, ifunction_vertex, g);
  add_stages(ts_ctx->getPreProcessIFunction(), ts_ctx->getLoopsIFunction(),
             ts_ctx->getPostProcessIFunction(), ifunction_vertex, g_ptr);
 
  auto rhsfunction_vertex = boost::add_vertex(g);
  vname[rhsfunction_vertex] = {"RHSFunction", "box3d", "filled", "lightgrey"};
  add_edge(root_vertex, rhsfunction_vertex, g);
  add_stages(ts_ctx->getPreProcessRHSFunction(), ts_ctx->getLoopsRHSFunction(),
             ts_ctx->getPostProcessRHSFunction(), rhsfunction_vertex, g_ptr);
 
  auto ijjacobian_vertex = boost::add_vertex(g);
  vname[ijjacobian_vertex] = {"IJacobian", "box3d", "filled", "lightgrey"};
  add_edge(root_vertex, ijjacobian_vertex, g);
  add_stages(ts_ctx->getPreProcessIJacobian(), ts_ctx->getLoopsIJacobian(),
             ts_ctx->getPostProcessIJacobian(), ijjacobian_vertex, g_ptr);
 
  auto rhsjacobian_vertex = boost::add_vertex(g);
  vname[rhsjacobian_vertex] = {"RHSJacobian", "box3d", "filled", "lightgrey"};
  add_edge(root_vertex, rhsjacobian_vertex, g);
  add_stages(ts_ctx->getPreProcessRHSJacobian(), ts_ctx->getLoopsRHSJacobian(),
             ts_ctx->getPostProcessRHSJacobian(), rhsjacobian_vertex, g_ptr);
 
  auto monitor_vertex = boost::add_vertex(g);
  vname[monitor_vertex] = {"Monitor", "box3d", "filled", "lightgrey"};
  add_edge(root_vertex, monitor_vertex, g);
  add_stages(ts_ctx->getPreProcessMonitor(), ts_ctx->getLoopsMonitor(),
             ts_ctx->getPostProcessMonitor(), monitor_vertex, g_ptr);
 
  write_graphviz_impl(file_name, g_ptr);           
  MoFEMFunctionReturn(0);
}
 
MoFEMErrorCode
PipelineGraph::writePiplineManagerGraphGraphviz(std::string file_name,
                                                PipelineManager *pip_mng) {
  MoFEMFunctionBegin;
  boost::shared_ptr<Graph> g_ptr(new Graph());
  auto vname = get(boost::vertex_name, *g_ptr);
  auto root_vertex = boost::add_vertex(*g_ptr);
  vname[root_vertex] = {"Pipeline Manager Graph", "ellipse", "solid", "black"};
 
  // lhs
  if (pip_mng->getDomainLhsFE())
    plot_pipeline_graph_impl(pip_mng->getOpDomainLhsPipeline(),
                                 "DomainLhsPipeline", g_ptr, root_vertex);
  if (pip_mng->getBoundaryLhsFE())
    plot_pipeline_graph_impl(pip_mng->getOpBoundaryLhsPipeline(),
                                 "BoundaryLhsPipeline", g_ptr, root_vertex);
  if (pip_mng->getSkeletonLhsFE())
    plot_pipeline_graph_impl(pip_mng->getOpSkeletonLhsPipeline(),
                                 "SkeletonLhsPipeline", g_ptr, root_vertex);
 
  // rhs
  if (pip_mng->getDomainRhsFE())
    plot_pipeline_graph_impl(pip_mng->getOpDomainRhsPipeline(),
                                 "DomainRhsPipeline", g_ptr, root_vertex);
  if (pip_mng->getBoundaryRhsFE())
    plot_pipeline_graph_impl(pip_mng->getOpBoundaryRhsPipeline(),
                                 "BoundaryRhsPipeline", g_ptr, root_vertex);
 
  if (pip_mng->getSkeletonRhsFE())
    plot_pipeline_graph_impl(pip_mng->getOpSkeletonRhsPipeline(),
                                 "SkeletonRhsPipeline", g_ptr, root_vertex);
  // rhs explict
  if (pip_mng->getDomainExplicitRhsFE())
    plot_pipeline_graph_impl(pip_mng->getOpDomainExplicitRhsPipeline(),
                                 "DomainRhsExplicitPipeline", g_ptr,
                                 root_vertex);
  if (pip_mng->getBoundaryExplicitRhsFE())
    plot_pipeline_graph_impl(pip_mng->getOpBoundaryExplicitRhsPipeline(),
                                 "BoundaryRhsExplicitPipeline", g_ptr,
                                 root_vertex);
  if (pip_mng->getSkeletonExplicitRhsFE())
    plot_pipeline_graph_impl(pip_mng->getOpSkeletonExplicitRhsPipeline(),
                                 "SkeletonRhsExplicitPipeline", g_ptr,
                                 root_vertex);
 
  // meshset
  if (pip_mng->getMeshsetLhsFE())
    plot_pipeline_graph_impl(pip_mng->getOpMeshsetLhsPipeline(),
                                 "MeshsetLhsPipeline", g_ptr, root_vertex);
  if (pip_mng->getMeshsetRhsFE())
    plot_pipeline_graph_impl(pip_mng->getOpMeshsetRhsPipeline(),
                                 "MeshsetRhsPipeline", g_ptr, root_vertex);
  if (pip_mng->getMeshsetExplicitRhsFE())
    plot_pipeline_graph_impl(pip_mng->getOpMeshsetExplicitRhsPipeline(),
                                 "MeshsetRhsExplicitPipeline", g_ptr,
                                 root_vertex);
 
  write_graphviz_impl(file_name, g_ptr);  
 
  MoFEMFunctionReturn(0);
}
 
MoFEMErrorCode
PipelineGraph::query_interface(boost::typeindex::type_index type_index,
                               UnknownInterface **iface) const {
  *iface = const_cast<PipelineGraph *>(this);
  return 0;
}
 
PipelineGraph::PipelineGraph(const MoFEM::Core &core)
    : cOre(const_cast<Core &>(core)) {}
 
} // namespace MoFEM