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 4272 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 4274 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);
        ts_ctx->getLoopsMonitor().push_back(
            TsCtx::PairNameFEMethodPtr(ep_ptr->elementVolumeName, monitor_ptr));
        // Registered after TsMonitorSet so they see this step's reactions.
        CHK_THROW_MESSAGE(
            EshelbianTesting::addMonitorTests(*ep_ptr, ts, monitor_ptr),
            "add monitor tests");
        CHK_THROW_MESSAGE(EshelbianTesting::addFinalTests(*ep_ptr, monitor_ptr),
                          "add final tests");
      }
      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_convergence_test = [&]() {
      MoFEMFunctionBegin;
      if (EshelbianCore::solverType ==
              EshelbianCore::SolverType::DynamicRelaxation &&
          (ep_ptr->dynamicAtol > 0 || ep_ptr->dynamicRtol > 0)) {
        auto snes_convergence_test =
            [](SNES snes, PetscInt it, PetscReal xnorm, PetscReal snorm,
               PetscReal fnorm, SNESConvergedReason *reason, void *cctx) {
              MoFEMFunctionBegin;
              auto ep_ptr = static_cast<EshelbianCore *>(cctx);
              CHKERR SNESConvergedDefault(snes, it, xnorm, snorm, fnorm, reason,
                                          PETSC_NULLPTR);
 
              if (it == 0) {
                if (ep_ptr->dynamicInitialResidual < 0)
                  ep_ptr->dynamicInitialResidual = fnorm;
 
                if (ep_ptr->dynamicAtol > 0 && fnorm < ep_ptr->dynamicAtol) {
                  *reason = SNES_BREAKOUT_INNER_ITER;
                  MOFEM_LOG_C(
                      "EP", Sev::inform,
                      "Stopping dynamic relaxation: SNES iteration 0 residual "
                      "%3.4e < %3.4e",
                      static_cast<double>(fnorm),
                      static_cast<double>(ep_ptr->dynamicAtol));
                } else if (ep_ptr->dynamicRtol > 0 &&
                           fnorm < ep_ptr->dynamicRtol *
                                       ep_ptr->dynamicInitialResidual) {
                  *reason = SNES_BREAKOUT_INNER_ITER;
                  MOFEM_LOG_C(
                      "EP", Sev::inform,
                      "Stopping dynamic relaxation: SNES iteration 0 residual "
                      "%3.4e < %3.4e * initial residual %3.4e",
                      static_cast<double>(fnorm),
                      static_cast<double>(ep_ptr->dynamicRtol),
                      static_cast<double>(ep_ptr->dynamicInitialResidual));
                }
 
                if (*reason == SNES_BREAKOUT_INNER_ITER) {
                  PetscObject ts_obj = PETSC_NULLPTR;
                  CHKERR PetscObjectQuery((PetscObject)snes,
                                          "dynamic_relaxation_ts", &ts_obj);
                  CHKERR TSSetConvergedReason((TS)ts_obj, TS_CONVERGED_USER);
                }
              }
 
              MoFEMFunctionReturn(0);
            };
 
        SNES snes;
        CHKERR TSGetSNES(ts, &snes);
        CHKERR PetscObjectCompose((PetscObject)snes, "dynamic_relaxation_ts",
                                  (PetscObject)ts);
        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;
    };
 
    CHK_THROW_MESSAGE(TSElasticPreAndPostStep::setPreStep(ep_ptr, ts, false),
                      "setup elastic pre-step");
 
    // 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_convergence_test(),
                           setup_section(), set_vector_on_mesh(),
                           setup_schur_block_solver());
#else
    return std::make_tuple(setup_ts_monitor(), setup_snes_monitor(),
                           setup_snes_convergence_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