MinimalSurfaceEqn Struct Reference

Collaboration diagram for MinimalSurfaceEqn:

Public Member Functions
	MinimalSurfaceEqn (MoFEM::Interface &m_field)
MoFEMErrorCode	runProgram ()

Private Member Functions
MoFEMErrorCode	readMesh ()
MoFEMErrorCode	setupProblem ()
MoFEMErrorCode	setIntegrationRules ()
MoFEMErrorCode	boundaryCondition ()
MoFEMErrorCode	assembleSystem ()
MoFEMErrorCode	solveSystem ()
MoFEMErrorCode	outputResults ()

Static Private Member Functions
static double	boundaryFunction (const double x, const double y, const double z)

Private Attributes
MoFEM::Interface &	mField
boost::shared_ptr< std::vector< unsigned char > >	boundaryMarker
Range	boundaryEnts

Detailed Description

Definition at line 176 of file minimal_surface_equation.cpp.

Constructor & Destructor Documentation

MinimalSurfaceEqn()

MinimalSurfaceEqn::MinimalSurfaceEqn

(

MoFEM::Interface &

m_field

)

Definition at line 207 of file minimal_surface_equation.cpp.

    : mField(m_field) {}

Member Function Documentation

assembleSystem()

MoFEMErrorCode MinimalSurfaceEqn::assembleSystem ( )

private

Definition at line 307 of file minimal_surface_equation.cpp.

                                                 {
  MoFEMFunctionBegin;
  auto add_domain_base_ops = [&](auto &pipeline) {
    auto det_ptr = boost::make_shared<VectorDouble>();
    auto jac_ptr = boost::make_shared<MatrixDouble>();
    auto inv_jac_ptr = boost::make_shared<MatrixDouble>();
    pipeline.push_back(new OpCalculateHOJac<2>(jac_ptr));
    pipeline.push_back(new OpInvertMatrix<2>(jac_ptr, det_ptr, inv_jac_ptr));
    pipeline.push_back(new OpSetHOInvJacToScalarBases<2>(H1, inv_jac_ptr));
    pipeline.push_back(new OpSetHOWeightsOnFace());
  };
 
  auto add_domain_lhs_ops = [&](auto &pipeline) {
    pipeline.push_back(new OpSetBc("U", true, boundaryMarker));
    auto grad_u_at_gauss_pts = boost::make_shared<MatrixDouble>();
    pipeline.push_back(
        new OpCalculateScalarFieldGradient<2>("U", grad_u_at_gauss_pts));
    pipeline.push_back(
        new OpDomainTangentMatrix("U", "U", grad_u_at_gauss_pts));
    pipeline.push_back(new OpUnSetBc("U"));
  };
 
  auto add_domain_rhs_ops = [&](auto &pipeline) {
    pipeline.push_back(new OpSetBc("U", true, boundaryMarker));
    auto grad_u_at_gauss_pts = boost::make_shared<MatrixDouble>();
    pipeline.push_back(
        new OpCalculateScalarFieldGradient<2>("U", grad_u_at_gauss_pts));
    pipeline.push_back(new OpDomainResidualVector("U", grad_u_at_gauss_pts));
    pipeline.push_back(new OpUnSetBc("U"));
  };
 
  auto add_boundary_base_ops = [&](auto &pipeline) {};
 
  auto add_lhs_base_ops = [&](auto &pipeline) {
    pipeline.push_back(new OpSetBc("U", false, boundaryMarker));
    pipeline.push_back(new OpBoundaryMass(
        "U", "U", [](const double, const double, const double) { return 1; }));
    pipeline.push_back(new OpUnSetBc("U"));
  };
  auto add_rhs_base_ops = [&](auto &pipeline) {
    pipeline.push_back(new OpSetBc("U", false, boundaryMarker));
    auto u_at_gauss_pts = boost::make_shared<VectorDouble>();
    pipeline.push_back(new OpCalculateScalarFieldValues("U", u_at_gauss_pts));
    pipeline.push_back(new OpBoundaryTimeScalarField(
        "U", u_at_gauss_pts,
        [](const double, const double, const double) { return 1; }));
    pipeline.push_back(new OpBoundarySource("U", boundaryFunction));
    pipeline.push_back(new OpUnSetBc("U"));
  };
 
  auto pipeline_mng = mField.getInterface<PipelineManager>();
  add_domain_base_ops(pipeline_mng->getOpDomainLhsPipeline());
  add_domain_base_ops(pipeline_mng->getOpDomainRhsPipeline());
  add_domain_lhs_ops(pipeline_mng->getOpDomainLhsPipeline());
  add_domain_rhs_ops(pipeline_mng->getOpDomainRhsPipeline());
 
  add_boundary_base_ops(pipeline_mng->getOpBoundaryLhsPipeline());
  add_boundary_base_ops(pipeline_mng->getOpBoundaryRhsPipeline());
  add_lhs_base_ops(pipeline_mng->getOpBoundaryLhsPipeline());
  add_rhs_base_ops(pipeline_mng->getOpBoundaryRhsPipeline());
 
  MoFEMFunctionReturn(0);
}

boundaryCondition()

MoFEMErrorCode MinimalSurfaceEqn::boundaryCondition ( )

private

Definition at line 266 of file minimal_surface_equation.cpp.

                                                    {
  MoFEMFunctionBegin;
 
  auto *simple = mField.getInterface<Simple>();
 
  auto get_ents_on_mesh_skin = [&]() {
    Range body_ents;
    CHKERR mField.get_moab().get_entities_by_dimension(0, 2, body_ents);
    Skinner skin(&mField.get_moab());
    Range skin_ents;
    CHKERR skin.find_skin(0, body_ents, false, skin_ents);
    // filter not owned entities, those are not on boundary
    Range boundary_ents;
    ParallelComm *pcomm =
        ParallelComm::get_pcomm(&mField.get_moab(), MYPCOMM_INDEX);
    pcomm->filter_pstatus(skin_ents, PSTATUS_SHARED | PSTATUS_MULTISHARED,
                          PSTATUS_NOT, -1, &boundary_ents);
 
    Range skin_verts;
    mField.get_moab().get_connectivity(boundary_ents, skin_verts, true);
    boundary_ents.merge(skin_verts);
    boundaryEnts = boundary_ents;
    return boundary_ents;
  };
 
  auto mark_boundary_dofs = [&](Range &&skin_edges) {
    auto problem_manager = mField.getInterface<ProblemsManager>();
    auto marker_ptr = boost::make_shared<std::vector<unsigned char>>();
    problem_manager->markDofs(simple->getProblemName(), ROW,
                              ProblemsManager::OR, skin_edges, *marker_ptr);
    return marker_ptr;
  };
 
  // Get global local vector of marked DOFs. Is global, since is set for all
  // DOFs on processor. Is local since only DOFs on processor are in the
  // vector. To access DOFs use local indices.
  boundaryMarker = mark_boundary_dofs(get_ents_on_mesh_skin());
 
  MoFEMFunctionReturn(0);
}

boundaryFunction()

static double MinimalSurfaceEqn::boundaryFunction ( const double  x, const double  y, const double  z  )

inlinestaticprivate

Definition at line 194 of file minimal_surface_equation.cpp.

                                                 {
    return sin(2 * M_PI * (x + y));
  }

outputResults()

MoFEMErrorCode MinimalSurfaceEqn::outputResults ( )

private

Definition at line 424 of file minimal_surface_equation.cpp.

                                                {
  MoFEMFunctionBegin;
 
  auto post_proc = boost::make_shared<PostProcEle>(mField);
 
  auto u_ptr = boost::make_shared<VectorDouble>();
  post_proc->getOpPtrVector().push_back(
      new OpCalculateScalarFieldValues("U", u_ptr));
 
  using OpPPMap = OpPostProcMapInMoab<2, 2>;
 
  post_proc->getOpPtrVector().push_back(
 
      new OpPPMap(post_proc->getPostProcMesh(),
                  post_proc->getMapGaussPts(),
 
                  {{"U", u_ptr}},
 
                  {}, {}, {}
 
                  )
 
  );
 
  auto *simple = mField.getInterface<Simple>();
  auto dm = simple->getDM();
  CHKERR DMoFEMLoopFiniteElements(dm, simple->getDomainFEName(), post_proc);
 
  CHKERR post_proc->writeFile("out_result.h5m");
 
  MoFEMFunctionReturn(0);
}

readMesh()

MoFEMErrorCode MinimalSurfaceEqn::readMesh ( )

private

Definition at line 224 of file minimal_surface_equation.cpp.

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

runProgram()

MoFEMErrorCode MinimalSurfaceEqn::runProgram

(

)

Definition at line 210 of file minimal_surface_equation.cpp.

                                             {
  MoFEMFunctionBegin;
 
  readMesh();
  setupProblem();
  setIntegrationRules();
  boundaryCondition();
  assembleSystem();
  solveSystem();
  outputResults();
 
  MoFEMFunctionReturn(0);
}

setIntegrationRules()

MoFEMErrorCode MinimalSurfaceEqn::setIntegrationRules ( )

private

Definition at line 250 of file minimal_surface_equation.cpp.

                                                      {
  MoFEMFunctionBegin;
 
  auto integration_rule = [](int o_row, int o_col, int approx_order) {
    return 2 * approx_order;
  };
 
  auto *pipeline_mng = mField.getInterface<PipelineManager>();
  CHKERR pipeline_mng->setDomainRhsIntegrationRule(integration_rule);
  CHKERR pipeline_mng->setDomainLhsIntegrationRule(integration_rule);
  CHKERR pipeline_mng->setBoundaryLhsIntegrationRule(integration_rule);
  CHKERR pipeline_mng->setBoundaryRhsIntegrationRule(integration_rule);
 
  MoFEMFunctionReturn(0);
}

setupProblem()

MoFEMErrorCode MinimalSurfaceEqn::setupProblem ( )

private

Definition at line 235 of file minimal_surface_equation.cpp.

                                               {
  MoFEMFunctionBegin;
 
  auto *simple = mField.getInterface<Simple>();
  CHKERR simple->addDomainField("U", H1, AINSWORTH_BERNSTEIN_BEZIER_BASE, 1);
  CHKERR simple->addBoundaryField("U", H1, AINSWORTH_BERNSTEIN_BEZIER_BASE, 1);
 
  int order = 3;
  CHKERR PetscOptionsGetInt(PETSC_NULL, "", "-order", &order, PETSC_NULL);
  CHKERR simple->setFieldOrder("U", order);
  CHKERR simple->setUp();
 
  MoFEMFunctionReturn(0);
}

solveSystem()

MoFEMErrorCode MinimalSurfaceEqn::solveSystem ( )

private

Definition at line 371 of file minimal_surface_equation.cpp.

                                              {
  MoFEMFunctionBegin;
 
  auto *simple = mField.getInterface<Simple>();
 
  auto set_fieldsplit_preconditioner = [&](auto snes) {
    MoFEMFunctionBeginHot;
    KSP ksp;
    CHKERR SNESGetKSP(snes, &ksp);
    PC pc;
    CHKERR KSPGetPC(ksp, &pc);
    PetscBool is_pcfs = PETSC_FALSE;
    PetscObjectTypeCompare((PetscObject)pc, PCFIELDSPLIT, &is_pcfs);
 
    if (is_pcfs == PETSC_TRUE) {
      auto bc_mng = mField.getInterface<BcManager>();
      auto name_prb = simple->getProblemName();
      SmartPetscObj<IS> is_all_bc;
      CHKERR mField.getInterface<ISManager>()->isCreateProblemFieldAndRank(
          name_prb, ROW, "U", 0, 1, is_all_bc, &boundaryEnts);
      int is_all_bc_size;
      CHKERR ISGetSize(is_all_bc, &is_all_bc_size);
      MOFEM_LOG("EXAMPLE", Sev::inform)
          << "Field split block size " << is_all_bc_size;
      CHKERR PCFieldSplitSetIS(pc, PETSC_NULL,
                               is_all_bc); // boundary block
    }
    MoFEMFunctionReturnHot(0);
  };
 
  // Create global RHS and solution vectors
  auto dm = simple->getDM();
  SmartPetscObj<Vec> global_rhs, global_solution;
  CHKERR DMCreateGlobalVector_MoFEM(dm, global_rhs);
  global_solution = vectorDuplicate(global_rhs);
 
  // Create nonlinear solver (SNES)
  auto pipeline_mng = mField.getInterface<PipelineManager>();
  auto solver = pipeline_mng->createSNES();
  CHKERR SNESSetFromOptions(solver);
  CHKERR set_fieldsplit_preconditioner(solver);
  CHKERR SNESSetUp(solver);
 
  // Solve the system
  CHKERR SNESSolve(solver, global_rhs, global_solution);
 
  // Scatter result data on the mesh
  CHKERR DMoFEMMeshToGlobalVector(dm, global_solution, INSERT_VALUES,
                                  SCATTER_REVERSE);
 
  MoFEMFunctionReturn(0);
}

Member Data Documentation

boundaryEnts

Range MinimalSurfaceEqn::boundaryEnts

private

Definition at line 204 of file minimal_surface_equation.cpp.

boundaryMarker

boost::shared_ptr<std::vector<unsigned char> > MinimalSurfaceEqn::boundaryMarker

private

Definition at line 203 of file minimal_surface_equation.cpp.

mField

MoFEM::Interface& MinimalSurfaceEqn::mField

private

Definition at line 200 of file minimal_surface_equation.cpp.

---

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

• tutorials/scl-5/minimal_surface_equation.cpp