Function Run

src/test/embed_potential/main.cpp:73–183

template <class M>
void Run(M& m, Vars& var) {
  auto sem = m.GetSem(__func__);
  using Scal = typename M::Scal;
  using Expr = typename M::Expr;
  using EB = Embed<M>;
  struct {
    std::unique_ptr<EB> eb;
    FieldCell<Scal> fcp;
    FieldEmbed<Scal> feg;
    FieldCell<Scal> fcdiv;
    FieldNode<Scal> fnl;
    std::shared_ptr<linear::Solver<M>> linsolver;
    typename UInitEmbedBc<M>::PlainBc bc;
    std::array<FieldCell<Scal>, M::dim + 1> comps;
    FieldCell<Scal> fc_residual;
    size_t nsteps;
    FieldCell<Scal> fc_gradexp;
    FieldCell<Expr> fc_system;
    std::array<FieldCell<Scal>, Expr::dim> fc_system_comps;
  } * ctx(sem);
  auto& t = *ctx;

  if (sem("ctor")) {
    m.flags.linreport = var.Int["linreport"];
    m.flags.check_symmetry = var.Int["check_symmetry"];
    t.eb.reset(new EB(m));
    t.linsolver = ULinear<M>::MakeLinearSolver(var, "symm", m);
    t.nsteps = var.Int["nsteps"];
    t.fcp.Reinit(m, 0);
  }
  if (sem.Nested("levelset")) {
    UEmbed<M>::InitLevelSet(t.fnl, m, var, m.IsRoot());
  }
  if (sem.Nested("init")) {
    t.eb->Init(t.fnl);
  }
  if (sem("bc")) {
    t.bc = UInitEmbedBc<M>::GetPlainBc(var.String["bc_path"], *t.eb, {});
    if (m.IsRoot()) {
      std::ofstream fdesc("bc_groups.dat");
      for (size_t i = 0; i < t.bc.vdesc.size(); ++i) {
        fdesc << i << " " << t.bc.vdesc[i] << std::endl;
      }
    }
  }
  if (sem.Nested("dump-eb")) {
    t.eb->DumpPoly();
  }
  if (sem.Nested("dump-bc")) {
    UInitEmbedBc<M>::DumpBcPoly("bc.vtk", t.bc.me_group, *t.eb, m);
  }
  for (size_t i = 0; i < t.nsteps; ++i) {
    if (sem.Nested("potential")) {
      CalcPotential(
          t.bc.mebc, m, *t.eb, t.fcp, t.feg, t.fc_residual, t.linsolver,
          t.fc_system);
    }
    if (sem("dump-solution")) {