EshelbianPlasticity::solve_elastic_setup Struct Reference

Static Public Member Functions
static auto	setup (EshelbianCore *ep_ptr, TS ts, Vec x, bool set_ts_monitor)

Detailed Description

Definition at line 4228 of file EshelbianPlasticity.cpp.

Member Function Documentation

setup()

static auto EshelbianPlasticity::solve_elastic_setup::setup ( EshelbianCore *  ep_ptr, TS  ts, Vec  x, bool  set_ts_monitor  )

inlinestatic

Definition at line 4230 of file EshelbianPlasticity.cpp.

                                                {
 
#ifdef ENABLE_PYTHON_BINDING
    auto setup_sdf = [&]() { return setupContactSdf(ep_ptr->mField); };
#endif
 
    auto setup_ts_monitor = [&]() {
      boost::shared_ptr<TsCtx> ts_ctx;
      CHK_THROW_MESSAGE(DMMoFEMGetTsCtx(ep_ptr->dmElastic, ts_ctx),
                        "get TS ctx");
      if (set_ts_monitor) {
        CHK_THROW_MESSAGE(
            TSMonitorSet(ts, TsMonitorSet, ts_ctx.get(), PETSC_NULLPTR),
            "TS monitor set");
        auto monitor_ptr = boost::make_shared<EshelbianMonitor>(*ep_ptr);
        auto testing_monitor_ptr =
            boost::make_shared<EshelbianTestingMonitor>(*ep_ptr, monitor_ptr);
        ts_ctx->getLoopsMonitor().push_back(
            TsCtx::PairNameFEMethodPtr(ep_ptr->elementVolumeName, monitor_ptr));
 
        PetscBool test_cook_flg = PETSC_FALSE;
        PetscBool test_cook_pts_flg = PETSC_FALSE;
        PetscInt atom_test = 0;
        CHKERR PetscOptionsGetBool(PETSC_NULLPTR, "", "-test_cook",
                                   &test_cook_flg, PETSC_NULLPTR);
        CHKERR PetscOptionsGetBool(PETSC_NULLPTR, "", "-test_cook_pts",
                                   &test_cook_pts_flg, PETSC_NULLPTR);
        CHKERR PetscOptionsGetInt(PETSC_NULLPTR, "", "-atom_test", &atom_test,
                                  PETSC_NULLPTR);
        if (atom_test || test_cook_flg || test_cook_pts_flg) {
          ts_ctx->getLoopsMonitor().push_back(TsCtx::PairNameFEMethodPtr(
              ep_ptr->elementVolumeName, testing_monitor_ptr));
        }
      }
      MOFEM_LOG("EP", Sev::inform) << "TS monitor setup";
      return std::make_tuple(ts_ctx);
    };
 
    auto setup_snes_monitor = [&]() {
      MoFEMFunctionBeginHot;
      SNES snes;
      CHKERR TSGetSNES(ts, &snes);
      auto snes_ctx = getDMSnesCtx(ep_ptr->dmElastic);
      CHKERR SNESMonitorSet(snes,
                            (MoFEMErrorCode (*)(SNES, PetscInt, PetscReal,
                                                void *))MoFEMSNESMonitorEnergy,
                            (void *)(snes_ctx.get()), PETSC_NULLPTR);
      MOFEM_LOG("EP", Sev::inform) << "SNES monitor setup";
      MoFEMFunctionReturnHot(0);
    };
 
    auto setup_snes_conergence_test = [&]() {
      MoFEMFunctionBegin;
 
      auto snes_convergence_test = [](SNES snes, PetscInt it, PetscReal xnorm,
                                      PetscReal snorm, PetscReal fnorm,
                                      SNESConvergedReason *reason, void *cctx) {
        MoFEMFunctionBegin;
        // EshelbianCore *ep_ptr = (EshelbianCore *)cctx;
        CHKERR SNESConvergedDefault(snes, it, xnorm, snorm, fnorm, reason,
                                    PETSC_NULLPTR);
 
        Vec x_update, r;
        CHKERR SNESGetSolutionUpdate(snes, &x_update);
        CHKERR SNESGetFunction(snes, &r, PETSC_NULLPTR, PETSC_NULLPTR);
 
        MoFEMFunctionReturn(0);
      };
 
      // SNES snes;
      // CHKERR TSGetSNES(ts, &snes);
      // CHKERR SNESSetConvergenceTest(snes, snes_convergence_test, ep_ptr,
      //                               PETSC_NULLPTR);
      // MOFEM_LOG("EP", Sev::inform) << "SNES convergence test setup";
      MoFEMFunctionReturn(0);
    };
 
    auto setup_section = [&]() {
      PetscSection section_raw;
      CHK_THROW_MESSAGE(DMGetSection(ep_ptr->dmElastic, &section_raw),
                        "get DM section");
      int num_fields;
      CHK_THROW_MESSAGE(PetscSectionGetNumFields(section_raw, &num_fields),
                        "get num fields");
      for (int ff = 0; ff != num_fields; ff++) {
        const char *field_name;
        CHK_THROW_MESSAGE(
            PetscSectionGetFieldName(section_raw, ff, &field_name),
            "get field name");
        MOFEM_LOG_C("EP", Sev::inform, "Field %d name %s", ff, field_name);
      }
      return SmartPetscObj<PetscSection>(section_raw, true);
    };
 
    auto set_vector_on_mesh = [&]() {
      MoFEMFunctionBeginHot;
      CHKERR DMoFEMMeshToLocalVector(ep_ptr->dmElastic, x, INSERT_VALUES,
                                     SCATTER_FORWARD);
      CHKERR VecGhostUpdateBegin(x, INSERT_VALUES, SCATTER_FORWARD);
      CHKERR VecGhostUpdateEnd(x, INSERT_VALUES, SCATTER_FORWARD);
      MOFEM_LOG("EP", Sev::inform) << "Vector set on mesh";
      MoFEMFunctionReturnHot(0);
    };
 
    auto setup_schur_block_solver = [&]() {
      MOFEM_LOG("EP", Sev::inform) << "Setting up Schur block solver";
      CHK_THROW_MESSAGE(TSAppendOptionsPrefix(ts, "elastic_"),
                        "append options prefix");
      CHK_THROW_MESSAGE(TSSetFromOptions(ts), "set from options");
      CHK_THROW_MESSAGE(TSSetDM(ts, ep_ptr->dmElastic), "set DM");
      // Adding field split solver
      boost::shared_ptr<EshelbianCore::SetUpSchur> schur_ptr;
      if constexpr (A == AssemblyType::BLOCK_MAT) {
        schur_ptr =
            EshelbianCore::SetUpSchur::createSetUpSchur(ep_ptr->mField, ep_ptr);
        CHK_THROW_MESSAGE(schur_ptr->setUp(ts), "setup schur");
      }
      MOFEM_LOG("EP", Sev::inform) << "Setting up Schur block solver done";
      return schur_ptr;
    };
 
    // Warning: sequence of construction is not guaranteed for tuple. You have
    // to enforce order by proper packaging.
 
#ifdef ENABLE_PYTHON_BINDING
    return std::make_tuple(setup_sdf(), setup_ts_monitor(),
                           setup_snes_monitor(), setup_snes_conergence_test(),
                           setup_section(), set_vector_on_mesh(),
                           setup_schur_block_solver());
#else
    return std::make_tuple(setup_ts_monitor(), setup_snes_monitor(),
                           setup_snes_conergence_test(), setup_section(),
                           set_vector_on_mesh(), setup_schur_block_solver());
#endif
  }

---

The documentation for this struct was generated from the following file:

• users_modules/eshelbian_plasticity/src/impl/EshelbianPlasticity.cpp