Poisson2DNonhomogeneous Struct Reference

Collaboration diagram for Poisson2DNonhomogeneous:

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

Private Member Functions
MoFEMErrorCode	readMesh ()
	[Read mesh] More...
MoFEMErrorCode	setupProblem ()
	[Read mesh] More...
MoFEMErrorCode	boundaryCondition ()
	[Setup problem] More...
MoFEMErrorCode	assembleSystem ()
	[Boundary condition] More...
MoFEMErrorCode	setIntegrationRules ()
	[Assemble system] More...
MoFEMErrorCode	solveSystem ()
	[Set integration rules] More...
MoFEMErrorCode	outputResults ()
	[Solve system] More...

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

Private Attributes
MoFEM::Interface &	mField
Simple *	simpleInterface
std::string	domainField
int	oRder
boost::shared_ptr< std::vector< unsigned char > >	boundaryMarker
Range	boundaryEntitiesForFieldsplit

Detailed Description

Definition at line 12 of file poisson_2d_nonhomogeneous.cpp.

Constructor & Destructor Documentation

Poisson2DNonhomogeneous()

Poisson2DNonhomogeneous::Poisson2DNonhomogeneous

(

MoFEM::Interface &

m_field

)

Definition at line 57 of file poisson_2d_nonhomogeneous.cpp.

    : domainField("U"), mField(m_field) {}

Member Function Documentation

assembleSystem()

MoFEMErrorCode Poisson2DNonhomogeneous::assembleSystem ( )

private

[Boundary condition]

[Assemble system]

Definition at line 108 of file poisson_2d_nonhomogeneous.cpp.

                                                       {
  MoFEMFunctionBegin;
 
  auto pipeline_mng = mField.getInterface<PipelineManager>();
 
  { // Push operators to the Pipeline that is responsible for calculating LHS of
    // domain elements
    CHKERR AddHOOps<SPACE_DIM, SPACE_DIM, SPACE_DIM>::add(
        pipeline_mng->getOpDomainLhsPipeline(), {H1});
    pipeline_mng->getOpDomainLhsPipeline().push_back(
        new OpSetBc(domainField, true, boundaryMarker));
    pipeline_mng->getOpDomainLhsPipeline().push_back(
        new OpDomainLhs(domainField, domainField));
    pipeline_mng->getOpDomainLhsPipeline().push_back(
        new OpUnSetBc(domainField));
  }
 
  { // Push operators to the Pipeline that is responsible for calculating RHS of
    // domain elements
    pipeline_mng->getOpDomainRhsPipeline().push_back(
        new OpSetBc(domainField, true, boundaryMarker));
    pipeline_mng->getOpDomainRhsPipeline().push_back(
        new OpDomainRhs(domainField, sourceTermFunction));
    pipeline_mng->getOpDomainRhsPipeline().push_back(
        new OpUnSetBc(domainField));
  }
 
  { // Push operators to the Pipeline that is responsible for calculating LHS of
    // boundary elements
    pipeline_mng->getOpBoundaryLhsPipeline().push_back(
        new OpSetBc(domainField, false, boundaryMarker));
    pipeline_mng->getOpBoundaryLhsPipeline().push_back(
        new OpBoundaryLhs(domainField, domainField));
    pipeline_mng->getOpBoundaryLhsPipeline().push_back(
        new OpUnSetBc(domainField));
  }
 
  { // Push operators to the Pipeline that is responsible for calculating RHS of
    // boundary elements
    pipeline_mng->getOpBoundaryRhsPipeline().push_back(
        new OpSetBc(domainField, false, boundaryMarker));
    pipeline_mng->getOpBoundaryRhsPipeline().push_back(
        new OpBoundaryRhs(domainField, boundaryFunction));
    pipeline_mng->getOpBoundaryRhsPipeline().push_back(
        new OpUnSetBc(domainField));
  }
 
  MoFEMFunctionReturn(0);
}

boundaryCondition()

MoFEMErrorCode Poisson2DNonhomogeneous::boundaryCondition ( )

private

[Setup problem]

[Boundary condition]

Definition at line 90 of file poisson_2d_nonhomogeneous.cpp.

                                                          {
  MoFEMFunctionBegin;
 
  auto bc_mng = mField.getInterface<BcManager>();
  CHKERR bc_mng->pushMarkDOFsOnEntities(simpleInterface->getProblemName(),
                                        "BOUNDARY_CONDITION", domainField, 0, 1,
                                        true);
  // merge markers from all blocksets "BOUNDARY_CONDITION"
  boundaryMarker = bc_mng->getMergedBlocksMarker({"BOUNDARY_CONDITION"});
  // get entities on blocksets "BOUNDARY_CONDITION"
  boundaryEntitiesForFieldsplit =
      bc_mng->getMergedBlocksRange({"BOUNDARY_CONDITION"});
 
  MoFEMFunctionReturn(0);
}

boundaryFunction()

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

inlinestaticprivate

Definition at line 36 of file poisson_2d_nonhomogeneous.cpp.

                                                 {
    return sin(x * 10.) * cos(y * 10.);
    // return 0;
  }

outputResults()

MoFEMErrorCode Poisson2DNonhomogeneous::outputResults ( )

private

[Solve system]

[Output results]

Definition at line 231 of file poisson_2d_nonhomogeneous.cpp.

                                                      {
  MoFEMFunctionBegin;
 
  auto pipeline_mng = mField.getInterface<PipelineManager>();
  pipeline_mng->getDomainLhsFE().reset();
  pipeline_mng->getBoundaryLhsFE().reset();
  pipeline_mng->getDomainRhsFE().reset();
  pipeline_mng->getBoundaryRhsFE().reset();
 
  auto d_ptr = boost::make_shared<VectorDouble>();
  auto l_ptr = boost::make_shared<VectorDouble>();
 
  using OpPPMap = OpPostProcMapInMoab<SPACE_DIM, SPACE_DIM>;
 
  auto post_proc_fe = boost::make_shared<PostProcFaceEle>(mField);
 
  post_proc_fe->getOpPtrVector().push_back(
      new OpCalculateScalarFieldValues(domainField, d_ptr));
  post_proc_fe->getOpPtrVector().push_back(new OpPPMap(
      post_proc_fe->getPostProcMesh(), post_proc_fe->getMapGaussPts(),
      {{domainField, d_ptr}}, {}, {}, {}));
  pipeline_mng->getDomainRhsFE() = post_proc_fe;
 
  CHKERR pipeline_mng->loopFiniteElements();
  CHKERR post_proc_fe->writeFile("out_result.h5m");
 
  MoFEMFunctionReturn(0);
}

readMesh()

MoFEMErrorCode Poisson2DNonhomogeneous::readMesh ( )

private

[Read mesh]

Definition at line 60 of file poisson_2d_nonhomogeneous.cpp.

                                                 {
  MoFEMFunctionBegin;
 
  CHKERR mField.getInterface(simpleInterface);
  CHKERR simpleInterface->getOptions();
  CHKERR simpleInterface->loadFile();
 
  MoFEMFunctionReturn(0);
}

runProgram()

MoFEMErrorCode Poisson2DNonhomogeneous::runProgram

(

)

Definition at line 260 of file poisson_2d_nonhomogeneous.cpp.

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

setIntegrationRules()

MoFEMErrorCode Poisson2DNonhomogeneous::setIntegrationRules ( )

private

[Assemble system]

[Set integration rules]

Definition at line 160 of file poisson_2d_nonhomogeneous.cpp.

                                                            {
  MoFEMFunctionBegin;
 
  auto pipeline_mng = mField.getInterface<PipelineManager>();
 
  auto domain_rule_lhs = [](int, int, int p) -> int { return 2 * (p - 1); };
  auto domain_rule_rhs = [](int, int, int p) -> int { return 2 * (p - 1); };
  CHKERR pipeline_mng->setDomainLhsIntegrationRule(domain_rule_lhs);
  CHKERR pipeline_mng->setDomainRhsIntegrationRule(domain_rule_rhs);
 
  auto boundary_rule_lhs = [](int, int, int p) -> int { return 2 * p; };
  auto boundary_rule_rhs = [](int, int, int p) -> int { return 2 * p; };
  CHKERR pipeline_mng->setBoundaryLhsIntegrationRule(boundary_rule_lhs);
  CHKERR pipeline_mng->setBoundaryLhsIntegrationRule(boundary_rule_rhs);
 
  MoFEMFunctionReturn(0);
}

setupProblem()

MoFEMErrorCode Poisson2DNonhomogeneous::setupProblem ( )

private

[Read mesh]

[Setup problem]

Definition at line 72 of file poisson_2d_nonhomogeneous.cpp.

                                                     {
  MoFEMFunctionBegin;
 
  CHKERR simpleInterface->addDomainField(domainField, H1,
                                         AINSWORTH_BERNSTEIN_BEZIER_BASE, 1);
  CHKERR simpleInterface->addBoundaryField(domainField, H1,
                                           AINSWORTH_BERNSTEIN_BEZIER_BASE, 1);
  int oRder = 3;
  CHKERR PetscOptionsGetInt(PETSC_NULL, "", "-order", &oRder, PETSC_NULL);
  CHKERR simpleInterface->setFieldOrder(domainField, oRder);
 
  CHKERR simpleInterface->setUp();
 
  MoFEMFunctionReturn(0);
}

solveSystem()

MoFEMErrorCode Poisson2DNonhomogeneous::solveSystem ( )

private

[Set integration rules]

[Solve system]

Definition at line 180 of file poisson_2d_nonhomogeneous.cpp.

                                                    {
  MoFEMFunctionBegin;
 
  auto pipeline_mng = mField.getInterface<PipelineManager>();
 
  auto ksp_solver = pipeline_mng->createKSP();
  CHKERR KSPSetFromOptions(ksp_solver);
 
  // Create RHS and solution vectors
  auto dm = simpleInterface->getDM();
  auto F = createDMVector(dm);
  auto D = vectorDuplicate(F);
 
  // Setup fieldsplit (block) solver - optional: yes/no
  if (1) {
    PC pc;
    CHKERR KSPGetPC(ksp_solver, &pc);
    PetscBool is_pcfs = PETSC_FALSE;
    PetscObjectTypeCompare((PetscObject)pc, PCFIELDSPLIT, &is_pcfs);
 
    // Set up FIELDSPLIT, only when user set -pc_type fieldsplit
    // Identify the index for boundary entities, remaining will be for domain
    // Then split the fields for boundary and domain for solving
    if (is_pcfs == PETSC_TRUE) {
      IS is_domain, is_boundary;
      const MoFEM::Problem *problem_ptr;
      CHKERR DMMoFEMGetProblemPtr(dm, &problem_ptr);
      CHKERR mField.getInterface<ISManager>()->isCreateProblemFieldAndRank(
          problem_ptr->getName(), ROW, domainField, 0, 1, &is_boundary,
          &boundaryEntitiesForFieldsplit);
      // CHKERR ISView(is_boundary, PETSC_VIEWER_STDOUT_SELF);
      CHKERR PCFieldSplitSetIS(pc, NULL, is_boundary);
      CHKERR ISDestroy(&is_boundary);
    }
  }
 
  CHKERR KSPSetUp(ksp_solver);
 
  // Solve the system
  CHKERR KSPSolve(ksp_solver, F, D);
 
  // Scatter result data on the mesh
  CHKERR VecGhostUpdateBegin(D, INSERT_VALUES, SCATTER_FORWARD);
  CHKERR VecGhostUpdateEnd(D, INSERT_VALUES, SCATTER_FORWARD);
  CHKERR DMoFEMMeshToLocalVector(dm, D, INSERT_VALUES, SCATTER_REVERSE);
 
  MoFEMFunctionReturn(0);
}

sourceTermFunction()

static double Poisson2DNonhomogeneous::sourceTermFunction ( const double  x, const double  y, const double  z  )

inlinestaticprivate

Definition at line 30 of file poisson_2d_nonhomogeneous.cpp.

                                                   {
    return 200 * sin(x * 10.) * cos(y * 10.);
    // return 1;
  }

Member Data Documentation

boundaryEntitiesForFieldsplit

Range Poisson2DNonhomogeneous::boundaryEntitiesForFieldsplit

private

Definition at line 54 of file poisson_2d_nonhomogeneous.cpp.

boundaryMarker

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

private

Definition at line 51 of file poisson_2d_nonhomogeneous.cpp.

domainField

std::string Poisson2DNonhomogeneous::domainField

private

Definition at line 47 of file poisson_2d_nonhomogeneous.cpp.

mField

MoFEM::Interface& Poisson2DNonhomogeneous::mField

private

Definition at line 43 of file poisson_2d_nonhomogeneous.cpp.

oRder

int Poisson2DNonhomogeneous::oRder

private

Definition at line 48 of file poisson_2d_nonhomogeneous.cpp.

simpleInterface

Simple* Poisson2DNonhomogeneous::simpleInterface

private

Definition at line 44 of file poisson_2d_nonhomogeneous.cpp.

---

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

• users_modules/tutorials/scl-2/poisson_2d_nonhomogeneous.cpp