StandardPoisson Struct Reference

Collaboration diagram for StandardPoisson:

Classes
struct	CommonData
	[Source function] More...
struct	OpError

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

Private Member Functions
MoFEMErrorCode	readMesh ()
MoFEMErrorCode	setupProblem ()
MoFEMErrorCode	boundaryCondition ()
MoFEMErrorCode	createCommonData ()
	[Create common data]
MoFEMErrorCode	assembleSystem ()
	[Create common data]
MoFEMErrorCode	setIntegrationRules ()
MoFEMErrorCode	solveSystem ()
MoFEMErrorCode	checkError ()
	[Check error]
MoFEMErrorCode	outputResults ()
	[Check error]

Static Private Member Functions
static double	analyticalFunction (const double x, const double y, const double z)
	[Analytical function]
static VectorDouble	analyticalFunctionGrad (const double x, const double y, const double z)
	[Analytical function]
static double	sourceFunction (const double x, const double y, const double z)
	[Analytical function gradient]

Private Attributes
boost::shared_ptr< CommonData >	commonDataPtr
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 24 of file standard_poisson.cpp.

Constructor & Destructor Documentation

StandardPoisson()

StandardPoisson::StandardPoisson

(

MoFEM::Interface &

m_field

)

Definition at line 114 of file standard_poisson.cpp.

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

Member Function Documentation

analyticalFunction()

static double StandardPoisson::analyticalFunction ( const double x, const double y, const double z )

inlinestaticprivate

[Analytical function]

Definition at line 44 of file standard_poisson.cpp.

                                                   {
    return exp(-100. * (sqr(x) + sqr(y))) * cos(M_PI * x) * cos(M_PI * y);
  }

analyticalFunctionGrad()

static VectorDouble StandardPoisson::analyticalFunctionGrad ( const double x, const double y, const double z )

inlinestaticprivate

[Analytical function]

[Analytical function gradient]

Definition at line 51 of file standard_poisson.cpp.

                                                             {
    VectorDouble res;
    res.resize(2);
    res[0] = -exp(-100. * (sqr(x) + sqr(y))) *
             (200. * x * cos(M_PI * x) + M_PI * sin(M_PI * x)) * cos(M_PI * y);
    res[1] = -exp(-100. * (sqr(x) + sqr(y))) *
             (200. * y * cos(M_PI * y) + M_PI * sin(M_PI * y)) * cos(M_PI * x);
    return res;
  }

assembleSystem()

MoFEMErrorCode StandardPoisson::assembleSystem ( )

private

[Create common data]

Definition at line 175 of file standard_poisson.cpp.

                                               {
  MoFEMFunctionBegin;
 
  auto pipeline_mng = mField.getInterface<PipelineManager>();
 
  { // Push operators to the Pipeline that is responsible for calculating LHS of
    // domain elements
    CHKERR AddHOOps<2, 2, 2>::add(pipeline_mng->getOpDomainLhsPipeline(), {H1});
    auto unity = [](const double, const double, const double) { return 1; };
    pipeline_mng->getOpDomainLhsPipeline().push_back(
        new OpDomainGradGrad(domainField, domainField, unity));
  }
 
  { // Push operators to the Pipeline that is responsible for calculating RHS of
    // domain elements
    pipeline_mng->getOpDomainRhsPipeline().push_back(
        new OpDomainSource(domainField, sourceFunction));
  }
 
  MoFEMFunctionReturn(0);
}

boundaryCondition()

MoFEMErrorCode StandardPoisson::boundaryCondition ( )

private

Definition at line 144 of file standard_poisson.cpp.

                                                  {
  MoFEMFunctionBegin;
 
  auto bc_mng = mField.getInterface<BcManager>();
 
  // Remove BCs from blockset name "BOUNDARY_CONDITION" or SETU, note that you
  // can use regular expression to put list of blocksets;
  CHKERR bc_mng->removeBlockDOFsOnEntities<BcScalarMeshsetType<BLOCKSET>>(
      simpleInterface->getProblemName(), "BOUNDARY", std::string(domainField),
      true);
 
  MoFEMFunctionReturn(0);
}

checkError()

MoFEMErrorCode StandardPoisson::checkError ( )

private

[Check error]

Definition at line 242 of file standard_poisson.cpp.

                                           {
  MoFEMFunctionBegin;
  PipelineManager *pipeline_mng = mField.getInterface<PipelineManager>();
  pipeline_mng->getDomainLhsFE().reset();
  pipeline_mng->getDomainRhsFE().reset();
  pipeline_mng->getOpDomainRhsPipeline().clear();
 
  CHKERR AddHOOps<2, 2, 2>::add(pipeline_mng->getOpDomainRhsPipeline(), {H1});
 
  pipeline_mng->getOpDomainRhsPipeline().push_back(
      new OpCalculateScalarFieldValues(domainField, commonDataPtr->approxVals));
  pipeline_mng->getOpDomainRhsPipeline().push_back(
      new OpCalculateScalarFieldGradient<2>(domainField,
                                            commonDataPtr->approxValsGrad));
  pipeline_mng->getOpDomainRhsPipeline().push_back(
      new OpError(domainField, commonDataPtr, mField));
 
  CHKERR VecZeroEntries(commonDataPtr->petscVec);
 
  CHKERR pipeline_mng->loopFiniteElements();
 
  CHKERR VecAssemblyBegin(commonDataPtr->petscVec);
  CHKERR VecAssemblyEnd(commonDataPtr->petscVec);
  const double *array;
  CHKERR VecGetArrayRead(commonDataPtr->petscVec, &array);
  MOFEM_LOG("EXAMPLE", Sev::inform)
      << "Global error L2 norm: " << std::sqrt(array[0]);
  MOFEM_LOG("EXAMPLE", Sev::inform)
      << "Global error H1 seminorm: " << std::sqrt(array[1]);
  CHKERR VecRestoreArrayRead(commonDataPtr->petscVec, &array);
 
  MoFEMFunctionReturn(0);
}

createCommonData()

MoFEMErrorCode StandardPoisson::createCommonData ( )

private

[Create common data]

Definition at line 159 of file standard_poisson.cpp.

                                                 {
  MoFEMFunctionBegin;
  commonDataPtr = boost::make_shared<CommonData>();
  PetscInt ghosts[2] = {0, 1};
  if (!mField.get_comm_rank())
    commonDataPtr->petscVec =
        createGhostVector(mField.get_comm(), 2, 2, 0, ghosts);
  else
    commonDataPtr->petscVec =
        createGhostVector(mField.get_comm(), 0, 2, 2, ghosts);
  commonDataPtr->approxVals = boost::make_shared<VectorDouble>();
  commonDataPtr->approxValsGrad = boost::make_shared<MatrixDouble>();
  MoFEMFunctionReturn(0);
}

outputResults()

MoFEMErrorCode StandardPoisson::outputResults ( )

private

[Check error]

Definition at line 277 of file standard_poisson.cpp.

                                              {
  MoFEMFunctionBegin;
 
  auto pipeline_mng = mField.getInterface<PipelineManager>();
  pipeline_mng->getDomainLhsFE().reset();
  pipeline_mng->getBoundaryLhsFE().reset();
  pipeline_mng->getDomainRhsFE().reset();
  pipeline_mng->getBoundaryRhsFE().reset();
 
  using OpPPMap = OpPostProcMapInMoab<SPACE_DIM, SPACE_DIM>;
 
  auto post_proc_fe = boost::make_shared<PostProcFaceEle>(mField);
 
  CHKERR AddHOOps<2, 2, 2>::add(post_proc_fe->getOpPtrVector(), {H1});
 
  post_proc_fe->getOpPtrVector().push_back(
      new OpCalculateScalarFieldValues(domainField, commonDataPtr->approxVals));
  post_proc_fe->getOpPtrVector().push_back(
      new OpCalculateScalarFieldGradient<2>(domainField,
                                            commonDataPtr->approxValsGrad));
 
  post_proc_fe->getOpPtrVector().push_back(new OpPPMap(
      post_proc_fe->getPostProcMesh(), post_proc_fe->getMapGaussPts(),
      {{domainField, commonDataPtr->approxVals}},
      {{domainField + "_GRAD", commonDataPtr->approxValsGrad}}, {}, {}));
  pipeline_mng->getDomainRhsFE() = post_proc_fe;
 
  CHKERR pipeline_mng->loopFiniteElements();
  CHKERR post_proc_fe->writeFile("out_result.h5m");
 
  MoFEMFunctionReturn(0);
}

readMesh()

MoFEMErrorCode StandardPoisson::readMesh ( )

private

Definition at line 117 of file standard_poisson.cpp.

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

runProgram()

MoFEMErrorCode StandardPoisson::runProgram

(

)

Definition at line 310 of file standard_poisson.cpp.

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

setIntegrationRules()

MoFEMErrorCode StandardPoisson::setIntegrationRules ( )

private

Definition at line 197 of file standard_poisson.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 StandardPoisson::setupProblem ( )

private

Definition at line 127 of file standard_poisson.cpp.

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

solveSystem()

MoFEMErrorCode StandardPoisson::solveSystem ( )

private

Definition at line 215 of file standard_poisson.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);
 
  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);
}

sourceFunction()

static double StandardPoisson::sourceFunction ( const double x, const double y, const double z )

inlinestaticprivate

[Analytical function gradient]

[Source function]

Definition at line 64 of file standard_poisson.cpp.

                                                                               {
    return -exp(-100. * (sqr(x) + sqr(y))) *
           (400. * M_PI *
                (x * cos(M_PI * y) * sin(M_PI * x) +
                 y * cos(M_PI * x) * sin(M_PI * y)) +
            2. * (20000. * (sqr(x) + sqr(y)) - 200. - sqr(M_PI)) *
                cos(M_PI * x) * cos(M_PI * y));
  }

Member Data Documentation

boundaryEntitiesForFieldsplit

Range StandardPoisson::boundaryEntitiesForFieldsplit

private

Definition at line 111 of file standard_poisson.cpp.

boundaryMarker

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

private

Definition at line 108 of file standard_poisson.cpp.

commonDataPtr

boost::shared_ptr<CommonData> StandardPoisson::commonDataPtr

private

Definition at line 82 of file standard_poisson.cpp.

domainField

std::string StandardPoisson::domainField

private

Definition at line 104 of file standard_poisson.cpp.

mField

MoFEM::Interface& StandardPoisson::mField

private

Definition at line 100 of file standard_poisson.cpp.

oRder

int StandardPoisson::oRder

private

Definition at line 105 of file standard_poisson.cpp.

simpleInterface

Simple* StandardPoisson::simpleInterface

private

Definition at line 101 of file standard_poisson.cpp.

---

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

• tutorials/mix-0/standard_poisson.cpp