ExampleNonlinearElastic Struct Reference

#include "tutorials/vec-2/src/ExampleNonlinearElastic.hpp"

Inheritance diagram for ExampleNonlinearElastic:

Collaboration diagram for ExampleNonlinearElastic:

Public Member Functions
	ExampleNonlinearElastic (MoFEM::Interface &m_field)
MoFEMErrorCode	runProblem ()
	[Run problem]

Protected Member Functions
MoFEMErrorCode	readMesh ()
	[Run problem]
MoFEMErrorCode	setupProblem ()
	[Read mesh]
MoFEMErrorCode	boundaryCondition ()
	[Set up problem]
MoFEMErrorCode	assembleSystem ()
	[Boundary condition]
MoFEMErrorCode	TsSolve ()
	[Push operators to pipeline]
MoFEMErrorCode	gettingNorms ()
	[TS Solve]
MoFEMErrorCode	outputResults ()
	[Getting norms]
MoFEMErrorCode	checkResults ()
	[Postprocessing results]

Protected Attributes
MoFEM::Interface &	mField
boost::shared_ptr< DomainEle >	reactionFe

Detailed Description

Examples

ExampleArcLength.hpp, and ExampleNonlinearElastic.hpp.

Definition at line 10 of file ExampleNonlinearElastic.hpp.

Constructor & Destructor Documentation

ExampleNonlinearElastic()

ExampleNonlinearElastic::ExampleNonlinearElastic ( MoFEM::Interface & m_field )

inline

Examples

ExampleArcLength.hpp, and ExampleNonlinearElastic.hpp.

Definition at line 12 of file ExampleNonlinearElastic.hpp.

: mField(m_field) {}

Member Function Documentation

assembleSystem()

MoFEMErrorCode ExampleNonlinearElastic::assembleSystem ( )

protected

[Boundary condition]

[Push operators to pipeline]

Examples

ExampleArcLength.hpp, and ExampleNonlinearElastic.hpp.

Definition at line 147 of file ExampleNonlinearElastic.hpp.

                                                       {
  MoFEMFunctionBegin;
  auto *pipeline_mng = mField.getInterface<PipelineManager>();
 
  auto add_domain_ops_lhs = [&](auto &pip) {
    MoFEMFunctionBegin;
    CHKERR AddHOOps<SPACE_DIM, SPACE_DIM, SPACE_DIM>::add(pip, {H1},
                                                          "GEOMETRY");
    CHKERR HenckyOps::opFactoryDomainLhs<SPACE_DIM, PETSC, GAUSS, DomainEleOp>(
        mField, pip, "U", "MAT_ELASTIC", Sev::inform);
    MoFEMFunctionReturn(0);
  };
 
  auto add_domain_ops_rhs = [&](auto &pip) {
    MoFEMFunctionBegin;
    CHKERR AddHOOps<SPACE_DIM, SPACE_DIM, SPACE_DIM>::add(pip, {H1},
                                                          "GEOMETRY");
    CHKERR HenckyOps::opFactoryDomainRhs<SPACE_DIM, PETSC, GAUSS, DomainEleOp>(
        mField, pip, "U", "MAT_ELASTIC", Sev::inform);
    MoFEMFunctionReturn(0);
  };
 
  CHKERR add_domain_ops_lhs(pipeline_mng->getOpDomainLhsPipeline());
  CHKERR add_domain_ops_rhs(pipeline_mng->getOpDomainRhsPipeline());
 
  // push operators to reaction pipeline
  CHKERR add_domain_ops_rhs(reactionFe->getOpPtrVector());
  reactionFe->postProcessHook =
      EssentialPreProcReaction<DisplacementCubitBcData>(mField, reactionFe);
 
  MoFEMFunctionReturn(0);
}

boundaryCondition()

MoFEMErrorCode ExampleNonlinearElastic::boundaryCondition ( )

protected

[Set up problem]

[Boundary condition]

[Define gravity vector]

Examples

ExampleArcLength.hpp, and ExampleNonlinearElastic.hpp.

Definition at line 105 of file ExampleNonlinearElastic.hpp.

                                                          {
  MoFEMFunctionBegin;
  auto *pipeline_mng = mField.getInterface<PipelineManager>();
  auto simple = mField.getInterface<Simple>();
  auto bc_mng = mField.getInterface<BcManager>();
  auto time_scale = boost::make_shared<ExampleTimeScale>();
 
  auto integration_rule = [](int, int, int approx_order) {
    return 2 * (approx_order - 1) + 1;
  };
 
  CHKERR pipeline_mng->setDomainRhsIntegrationRule(integration_rule);
  CHKERR pipeline_mng->setDomainLhsIntegrationRule(integration_rule);
  CHKERR pipeline_mng->setBoundaryRhsIntegrationRule(integration_rule);
 
  reactionFe = boost::make_shared<DomainEle>(mField);
  reactionFe->getRuleHook = integration_rule;
 
  CHKERR BoundaryNaturalBC::AddFluxToPipeline<OpForce>::add(
      pipeline_mng->getOpBoundaryRhsPipeline(), mField, "U", {time_scale},
      "FORCE", Sev::inform);
 
  //! [Define gravity vector]
  CHKERR DomainNaturalBC::AddFluxToPipeline<OpBodyForce>::add(
      pipeline_mng->getOpDomainRhsPipeline(), mField, "U", {time_scale},
      "BODY_FORCE", Sev::inform);
 
  // Essential BC
  CHKERR bc_mng->removeBlockDOFsOnEntities(simple->getProblemName(), "REMOVE_X",
                                           "U", 0, 0);
  CHKERR bc_mng->removeBlockDOFsOnEntities(simple->getProblemName(), "REMOVE_Y",
                                           "U", 1, 1);
  CHKERR bc_mng->removeBlockDOFsOnEntities(simple->getProblemName(), "REMOVE_Z",
                                           "U", 2, 2);
  CHKERR bc_mng->pushMarkDOFsOnEntities<DisplacementCubitBcData>(
      simple->getProblemName(), "U");
 
  MoFEMFunctionReturn(0);
}

checkResults()

MoFEMErrorCode ExampleNonlinearElastic::checkResults ( )

protected

[Postprocessing results]

[Check]

Examples

ExampleNonlinearElastic.hpp.

Definition at line 432 of file ExampleNonlinearElastic.hpp.

                                                     {
  MoFEMFunctionBegin;
  PetscInt test_nb = 0;
  PetscBool test_flg = PETSC_FALSE;
  CHKERR PetscOptionsGetInt(PETSC_NULLPTR, "", "-test", &test_nb, &test_flg);
 
  if (test_flg) {
    auto simple = mField.getInterface<Simple>();
    auto T = createDMVector(simple->getDM());
    CHKERR DMoFEMMeshToLocalVector(simple->getDM(), T, INSERT_VALUES,
                                   SCATTER_FORWARD);
    double nrm2;
    CHKERR VecNorm(T, NORM_2, &nrm2);
    MOFEM_LOG("EXAMPLE", Sev::verbose) << "Regression norm " << nrm2;
    double regression_value = 0;
    switch (test_nb) {
    case 1:
      regression_value = 1.02789;
      break;
    case 2:
      regression_value = 1.8841e+00;
      break;
    case 3:
      regression_value = 1.8841e+00;
      break;
    default:
      SETERRQ(PETSC_COMM_WORLD, MOFEM_ATOM_TEST_INVALID, "Wrong test number.");
      break;
    }
    if (fabs(nrm2 - regression_value) > 1e-2)
      SETERRQ(PETSC_COMM_WORLD, MOFEM_ATOM_TEST_INVALID,
              "Regression test field; wrong norm value. %6.4e != %6.4e", nrm2,
              regression_value);
  }
  MoFEMFunctionReturn(0);
}

gettingNorms()

MoFEMErrorCode ExampleNonlinearElastic::gettingNorms ( )

protected

[TS Solve]

[Getting norms]

Examples

ExampleArcLength.hpp, and ExampleNonlinearElastic.hpp.

Definition at line 361 of file ExampleNonlinearElastic.hpp.

                                                     {
  MoFEMFunctionBegin;
 
  auto simple = mField.getInterface<Simple>();
  auto dm = simple->getDM();
 
  auto T = createDMVector(simple->getDM());
  CHKERR DMoFEMMeshToLocalVector(simple->getDM(), T, INSERT_VALUES,
                                 SCATTER_FORWARD);
  double nrm2;
  CHKERR VecNorm(T, NORM_2, &nrm2);
  MOFEM_LOG("EXAMPLE", Sev::inform) << "Solution norm " << nrm2;
 
  auto post_proc_norm_fe = boost::make_shared<DomainEle>(mField);
 
  auto post_proc_norm_rule_hook = [](int, int, int p) -> int { return 2 * p; };
  post_proc_norm_fe->getRuleHook = post_proc_norm_rule_hook;
 
  CHKERR AddHOOps<SPACE_DIM, SPACE_DIM, SPACE_DIM>::add(
      post_proc_norm_fe->getOpPtrVector(), {H1}, "GEOMETRY");
 
  enum NORMS { U_NORM_L2 = 0, PIOLA_NORM, LAST_NORM };
  auto norms_vec =
      createVectorMPI(mField.get_comm(),
                      (mField.get_comm_rank() == 0) ? LAST_NORM : 0, LAST_NORM);
  CHKERR VecZeroEntries(norms_vec);
 
  auto u_ptr = boost::make_shared<MatrixDouble>();
  post_proc_norm_fe->getOpPtrVector().push_back(
      new OpCalculateVectorFieldValues<SPACE_DIM>("U", u_ptr));
 
  post_proc_norm_fe->getOpPtrVector().push_back(
      new OpCalcNormL2Tensor1<SPACE_DIM>(u_ptr, norms_vec, U_NORM_L2));
 
  auto common_ptr = commonDataFactory<SPACE_DIM, GAUSS, DomainEleOp>(
      mField, post_proc_norm_fe->getOpPtrVector(), "U", "MAT_ELASTIC",
      Sev::inform);
 
  post_proc_norm_fe->getOpPtrVector().push_back(
      new OpCalcNormL2Tensor2<SPACE_DIM, SPACE_DIM>(
          common_ptr->getMatFirstPiolaStress(), norms_vec, PIOLA_NORM));
 
  CHKERR DMoFEMLoopFiniteElements(dm, simple->getDomainFEName(),
                                  post_proc_norm_fe);
 
  CHKERR VecAssemblyBegin(norms_vec);
  CHKERR VecAssemblyEnd(norms_vec);
 
  MOFEM_LOG_CHANNEL("SELF"); // Clear channel from old tags
  if (mField.get_comm_rank() == 0) {
    const double *norms;
    CHKERR VecGetArrayRead(norms_vec, &norms);
    MOFEM_TAG_AND_LOG("SELF", Sev::inform, "example")
        << "norm_u: " << std::scientific << std::sqrt(norms[U_NORM_L2]);
    MOFEM_TAG_AND_LOG("SELF", Sev::inform, "example")
        << "norm_piola: " << std::scientific << std::sqrt(norms[PIOLA_NORM]);
    CHKERR VecRestoreArrayRead(norms_vec, &norms);
  }
 
  MoFEMFunctionReturn(0);
}

outputResults()

MoFEMErrorCode ExampleNonlinearElastic::outputResults ( )

protected

[Getting norms]

[Postprocessing results]

Examples

ExampleArcLength.hpp, and ExampleNonlinearElastic.hpp.

Definition at line 425 of file ExampleNonlinearElastic.hpp.

                                                      {
  MoFEMFunctionBegin;
  MoFEMFunctionReturn(0);
}

readMesh()

MoFEMErrorCode ExampleNonlinearElastic::readMesh ( )

protected

[Run problem]

[Read mesh]

Examples

ExampleArcLength.hpp, and ExampleNonlinearElastic.hpp.

Definition at line 46 of file ExampleNonlinearElastic.hpp.

                                                 {
  MoFEMFunctionBegin;
  auto simple = mField.getInterface<Simple>();
  CHKERR simple->getOptions();
  CHKERR simple->loadFile();
  MoFEMFunctionReturn(0);
}

runProblem()

MoFEMErrorCode ExampleNonlinearElastic::runProblem

(

)

[Run problem]

Examples

ExampleNonlinearElastic.hpp.

Definition at line 31 of file ExampleNonlinearElastic.hpp.

                                                   {
  MoFEMFunctionBegin;
  CHKERR readMesh();
  CHKERR setupProblem();
  CHKERR boundaryCondition();
  CHKERR assembleSystem();
  CHKERR TsSolve();
  CHKERR gettingNorms();
  CHKERR outputResults();
  CHKERR checkResults();
  MoFEMFunctionReturn(0);
}

setupProblem()

MoFEMErrorCode ExampleNonlinearElastic::setupProblem ( )

protected

[Read mesh]

[Set up problem]

Examples

ExampleArcLength.hpp, and ExampleNonlinearElastic.hpp.

Definition at line 56 of file ExampleNonlinearElastic.hpp.

                                                     {
  MoFEMFunctionBegin;
  Simple *simple = mField.getInterface<Simple>();
 
  enum bases { AINSWORTH, DEMKOWICZ, LASBASETOPT };
  const char *list_bases[LASBASETOPT] = {"ainsworth", "demkowicz"};
  PetscInt choice_base_value = AINSWORTH;
  CHKERR PetscOptionsGetEList(PETSC_NULLPTR, NULL, "-base", list_bases,
                              LASBASETOPT, &choice_base_value, PETSC_NULLPTR);
 
  FieldApproximationBase base;
  switch (choice_base_value) {
  case AINSWORTH:
    base = AINSWORTH_LEGENDRE_BASE;
    MOFEM_LOG("WORLD", Sev::inform)
        << "Set AINSWORTH_LEGENDRE_BASE for displacements";
    break;
  case DEMKOWICZ:
    base = DEMKOWICZ_JACOBI_BASE;
    MOFEM_LOG("WORLD", Sev::inform)
        << "Set DEMKOWICZ_JACOBI_BASE for displacements";
    break;
  default:
    base = LASTBASE;
    break;
  }
 
  // Add field
  CHKERR simple->addDomainField("U", H1, base, SPACE_DIM);
  CHKERR simple->addBoundaryField("U", H1, base, SPACE_DIM);
  CHKERR simple->addDataField("GEOMETRY", H1, base, SPACE_DIM);
  int order = 2;
  CHKERR PetscOptionsGetInt(PETSC_NULLPTR, "", "-order", &order, PETSC_NULLPTR);
  CHKERR simple->setFieldOrder("U", order);
  CHKERR simple->setFieldOrder("GEOMETRY", 2);
  CHKERR simple->setUp();
 
  auto project_ho_geometry = [&]() {
    Projection10NodeCoordsOnField ent_method(mField, "GEOMETRY");
    return mField.loop_dofs("GEOMETRY", ent_method);
  };
  CHKERR project_ho_geometry();
 
  MoFEMFunctionReturn(0);
}

TsSolve()

MoFEMErrorCode ExampleNonlinearElastic::TsSolve ( )

protected

[Push operators to pipeline]

[TS Solve]

Examples

ExampleNonlinearElastic.hpp.

Definition at line 182 of file ExampleNonlinearElastic.hpp.

                                                {
  MoFEMFunctionBegin;
  auto *simple = mField.getInterface<Simple>();
  auto *pipeline_mng = mField.getInterface<PipelineManager>();
 
  auto dm = simple->getDM();
  auto ts = pipeline_mng->createTSIM();
 
  PetscBool post_proc_vol;
  PetscBool post_proc_skin;
 
  if constexpr (SPACE_DIM == 2) {
    post_proc_vol = PETSC_TRUE;
    post_proc_skin = PETSC_FALSE;
  } else {
    post_proc_vol = PETSC_FALSE;
    post_proc_skin = PETSC_TRUE;
  }
  CHKERR PetscOptionsGetBool(PETSC_NULLPTR, "", "-post_proc_vol",
                             &post_proc_vol, PETSC_NULLPTR);
  CHKERR PetscOptionsGetBool(PETSC_NULLPTR, "", "-post_proc_skin",
                             &post_proc_skin, PETSC_NULLPTR);
 
  // Setup postprocessing
  auto create_post_proc_fe = [dm, this, simple, post_proc_vol,
                              post_proc_skin]() {
    auto post_proc_ele_domain = [dm, this](auto &pip_domain) {
      CHKERR AddHOOps<SPACE_DIM, SPACE_DIM, SPACE_DIM>::add(pip_domain, {H1},
                                                            "GEOMETRY");
      auto common_ptr = commonDataFactory<SPACE_DIM, GAUSS, DomainEleOp>(
          mField, pip_domain, "U", "MAT_ELASTIC", Sev::inform);
      return common_ptr;
    };
 
    auto post_proc_map = [this](auto &pip, auto u_ptr, auto common_ptr) {
      MoFEMFunctionBegin;
 
      using OpPPMap = OpPostProcMapInMoab<SPACE_DIM, SPACE_DIM>;
 
      pip->getOpPtrVector().push_back(
 
          new OpPPMap(pip->getPostProcMesh(), pip->getMapGaussPts(), {},
                      {{"U", u_ptr}},
                      {{"GRAD", common_ptr->matGradPtr},
                       {"FIRST_PIOLA", common_ptr->getMatFirstPiolaStress()}},
                      {}));
      MoFEMFunctionReturn(0);
    };
 
    auto push_post_proc_bdy = [dm, this, simple, post_proc_skin,
                               &post_proc_ele_domain,
                               &post_proc_map](auto &pip_bdy) {
      if (post_proc_skin == PETSC_FALSE)
        return boost::shared_ptr<PostProcEleBdy>();
 
      auto u_ptr = boost::make_shared<MatrixDouble>();
      pip_bdy->getOpPtrVector().push_back(
          new OpCalculateVectorFieldValues<SPACE_DIM>("U", u_ptr));
      auto op_loop_side =
          new OpLoopSide<SideEle>(mField, simple->getDomainFEName(), SPACE_DIM);
      auto common_ptr = post_proc_ele_domain(op_loop_side->getOpPtrVector());
      pip_bdy->getOpPtrVector().push_back(op_loop_side);
 
      CHKERR post_proc_map(pip_bdy, u_ptr, common_ptr);
 
      return pip_bdy;
    };
 
    auto push_post_proc_domain = [dm, this, simple, post_proc_vol,
                                  &post_proc_ele_domain,
                                  &post_proc_map](auto &pip_domain) {
      if (post_proc_vol == PETSC_FALSE)
        return boost::shared_ptr<PostProcEleDomain>();
 
      auto u_ptr = boost::make_shared<MatrixDouble>();
      pip_domain->getOpPtrVector().push_back(
          new OpCalculateVectorFieldValues<SPACE_DIM>("U", u_ptr));
      auto common_ptr = post_proc_ele_domain(pip_domain->getOpPtrVector());
 
      CHKERR post_proc_map(pip_domain, u_ptr, common_ptr);
 
      return pip_domain;
    };
 
    auto post_proc_fe_domain = boost::make_shared<PostProcEleDomain>(mField);
    auto post_proc_fe_bdy = boost::make_shared<PostProcEleBdy>(mField);
 
    return std::make_pair(push_post_proc_domain(post_proc_fe_domain),
                          push_post_proc_bdy(post_proc_fe_bdy));
  };
 
  auto add_extra_finite_elements_to_solver_pipelines = [&]() {
    MoFEMFunctionBegin;
 
    auto pre_proc_ptr = boost::make_shared<FEMethod>();
    auto post_proc_rhs_ptr = boost::make_shared<FEMethod>();
    auto post_proc_lhs_ptr = boost::make_shared<FEMethod>();
 
    auto time_scale = boost::make_shared<ExampleTimeScale>();
 
    auto get_bc_hook_rhs = [this, pre_proc_ptr, time_scale]() {
      MoFEMFunctionBeginHot;
      CHKERR EssentialPreProc<DisplacementCubitBcData>(mField, pre_proc_ptr,
                                                       {time_scale}, false)();
      MoFEMFunctionReturnHot(0);
    };
 
    pre_proc_ptr->preProcessHook = get_bc_hook_rhs;
 
    auto get_post_proc_hook_rhs = [this, post_proc_rhs_ptr]() {
      MoFEMFunctionBegin;
      CHKERR EssentialPreProcReaction<DisplacementCubitBcData>(
          mField, post_proc_rhs_ptr, nullptr, Sev::verbose)();
      CHKERR EssentialPostProcRhs<DisplacementCubitBcData>(
          mField, post_proc_rhs_ptr, 1.)();
      MoFEMFunctionReturn(0);
    };
    auto get_post_proc_hook_lhs = [this, post_proc_lhs_ptr]() {
      MoFEMFunctionBegin;
      CHKERR EssentialPostProcLhs<DisplacementCubitBcData>(
          mField, post_proc_lhs_ptr, 1.)();
      MoFEMFunctionReturn(0);
    };
    post_proc_rhs_ptr->postProcessHook = get_post_proc_hook_rhs;
    post_proc_lhs_ptr->postProcessHook = get_post_proc_hook_lhs;
 
    // This is low level pushing finite elements (pipelines) to solver
    auto ts_ctx_ptr = getDMTsCtx(simple->getDM());
    ts_ctx_ptr->getPreProcessIFunction().push_front(pre_proc_ptr);
    ts_ctx_ptr->getPreProcessIJacobian().push_front(pre_proc_ptr);
    ts_ctx_ptr->getPostProcessIFunction().push_back(post_proc_rhs_ptr);
    ts_ctx_ptr->getPostProcessIJacobian().push_back(post_proc_lhs_ptr);
    MoFEMFunctionReturn(0);
  };
 
  // Add extra finite elements to SNES solver pipelines to resolve essential
  // boundary conditions
  CHKERR add_extra_finite_elements_to_solver_pipelines();
 
  auto create_monitor_fe = [dm](auto &&post_proc_fe, auto &&reactionFe) {
    return boost::make_shared<Monitor>(dm, post_proc_fe, reactionFe);
  };
 
  // Set monitor which postprocessing results and saves them to the hard drive
  boost::shared_ptr<FEMethod> null_fe;
  auto monitor_ptr = create_monitor_fe(create_post_proc_fe(), reactionFe);
  CHKERR DMMoFEMTSSetMonitor(dm, ts, simple->getDomainFEName(), null_fe,
                             null_fe, monitor_ptr);
 
  // Set time solver
  double ftime = 1;
  CHKERR TSSetMaxTime(ts, ftime);
  CHKERR TSSetExactFinalTime(ts, TS_EXACTFINALTIME_MATCHSTEP);
 
  auto B = createDMMatrix(dm);
  CHKERR TSSetI2Jacobian(ts, B, B, PETSC_NULLPTR, PETSC_NULLPTR);
  auto D = createDMVector(simple->getDM());
  CHKERR TSSetSolution(ts, D);
  CHKERR TSSetFromOptions(ts);
 
  CHKERR TSSolve(ts, NULL);
  CHKERR TSGetTime(ts, &ftime);
 
  PetscInt steps, snesfails, rejects, nonlinits, linits;
  CHKERR TSGetStepNumber(ts, &steps);
  CHKERR TSGetSNESFailures(ts, &snesfails);
  CHKERR TSGetStepRejections(ts, &rejects);
  CHKERR TSGetSNESIterations(ts, &nonlinits);
  CHKERR TSGetKSPIterations(ts, &linits);
  MOFEM_LOG_C("EXAMPLE", Sev::inform,
              "steps %d (%d rejected, %d SNES fails), ftime %g, nonlinits "
              "%d, linits %d",
              steps, rejects, snesfails, ftime, nonlinits, linits);
 
  MoFEMFunctionReturn(0);
}

Member Data Documentation

mField

MoFEM::Interface& ExampleNonlinearElastic::mField

protected

Examples

ExampleArcLength.hpp, and ExampleNonlinearElastic.hpp.

Definition at line 17 of file ExampleNonlinearElastic.hpp.

reactionFe

boost::shared_ptr<DomainEle> ExampleNonlinearElastic::reactionFe

protected

Examples

ExampleNonlinearElastic.hpp.

Definition at line 18 of file ExampleNonlinearElastic.hpp.

---

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

• tutorials/vec-2/src/ExampleNonlinearElastic.hpp