Poisson2DHomogeneous Struct Reference

Collaboration diagram for Poisson2DHomogeneous:

Public Member Functions
	Poisson2DHomogeneous (MoFEM::Interface &m_field)
MoFEMErrorCode	runProgram ()
	[Check]

Private Types
enum	NORMS { NORM = 0 , LAST_NORM }

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

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

Private Attributes
Simple *	simpleInterface
MoFEM::Interface &	mField
int	oRder
SmartPetscObj< Vec >	petscVec
int	atom_test = 0

Detailed Description

Examples

mofem/tutorials/scl-1_poisson_2d_homogeneous/poisson_2d_homogeneous.cpp.

Definition at line 27 of file poisson_2d_homogeneous.cpp.

Member Enumeration Documentation

NORMS

enum Poisson2DHomogeneous::NORMS

private

Enumerator
NORM
LAST_NORM

Examples

mofem/tutorials/scl-1_poisson_2d_homogeneous/poisson_2d_homogeneous.cpp.

Definition at line 59 of file poisson_2d_homogeneous.cpp.

{ NORM = 0, LAST_NORM };

Constructor & Destructor Documentation

Poisson2DHomogeneous()

Poisson2DHomogeneous::Poisson2DHomogeneous

(

MoFEM::Interface &

m_field

)

Examples

mofem/tutorials/scl-1_poisson_2d_homogeneous/poisson_2d_homogeneous.cpp.

Definition at line 62 of file poisson_2d_homogeneous.cpp.

    : mField(m_field) {}

Member Function Documentation

assembleSystem()

MoFEMErrorCode Poisson2DHomogeneous::assembleSystem ( )

private

[Boundary condition]

[Assemble system]

Examples

mofem/tutorials/scl-1_poisson_2d_homogeneous/poisson_2d_homogeneous.cpp.

Definition at line 149 of file poisson_2d_homogeneous.cpp.

                                                    {
  MoFEMFunctionBegin;
 
  auto pipeline_mng = mField.getInterface<PipelineManager>();
 
  { // Push operators to the Pipeline that is responsible for calculating LHS
    CHKERR AddHOOps<SPACE_DIM, SPACE_DIM, SPACE_DIM>::add(
        pipeline_mng->getOpDomainLhsPipeline(), {H1});
    pipeline_mng->getOpDomainLhsPipeline().push_back(
        new OpDomainLhsMatrixK(field_name, field_name));
  }
 
  { // Push operators to the Pipeline that is responsible for calculating RHS
 
    auto set_values_to_bc_dofs = [&](auto &fe) {
      auto get_bc_hook = [&]() {
        EssentialPreProc<TemperatureCubitBcData> hook(mField, fe, {});
        return hook;
      };
      fe->preProcessHook = get_bc_hook();
    };
 
    // you can skip that if boundary condition is prescribing zero
    auto calculate_residual_from_set_values_on_bc = [&](auto &pipeline) {
      using DomainEle =
          PipelineManager::ElementsAndOpsByDim<SPACE_DIM>::DomainEle;
      using DomainEleOp = DomainEle::UserDataOperator;
      using OpInternal = FormsIntegrators<DomainEleOp>::Assembly<
          PETSC>::LinearForm<GAUSS>::OpGradTimesTensor<1, 1, SPACE_DIM>;
 
      auto grad_u_vals_ptr = boost::make_shared<MatrixDouble>();
      pipeline_mng->getOpDomainRhsPipeline().push_back(
          new OpCalculateScalarFieldGradient<SPACE_DIM>(field_name,
                                                        grad_u_vals_ptr));
      pipeline_mng->getOpDomainRhsPipeline().push_back(
          new OpInternal(field_name, grad_u_vals_ptr,
                         [](double, double, double) constexpr { return -1; }));
    };
 
    CHKERR AddHOOps<SPACE_DIM, SPACE_DIM, SPACE_DIM>::add(
        pipeline_mng->getOpDomainRhsPipeline(), {H1});
    set_values_to_bc_dofs(pipeline_mng->getDomainRhsFE());
    calculate_residual_from_set_values_on_bc(
        pipeline_mng->getOpDomainRhsPipeline());
    pipeline_mng->getOpDomainRhsPipeline().push_back(
        new OpDomainRhsVectorF(field_name, sourceTermFunction));
  }
 
  MoFEMFunctionReturn(0);
}

boundaryCondition()

MoFEMErrorCode Poisson2DHomogeneous::boundaryCondition ( )

private

[Setup problem]

[Boundary condition]

Examples

mofem/tutorials/scl-1_poisson_2d_homogeneous/poisson_2d_homogeneous.cpp.

Definition at line 133 of file poisson_2d_homogeneous.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_CONDITION|SETU)",
      std::string(field_name), true);
 
  MoFEMFunctionReturn(0);
}

checkResults()

MoFEMErrorCode Poisson2DHomogeneous::checkResults ( )

private

[Output results]

[Check]

Examples

mofem/tutorials/scl-1_poisson_2d_homogeneous/poisson_2d_homogeneous.cpp.

Definition at line 290 of file poisson_2d_homogeneous.cpp.

                                                  {
  MoFEMFunctionBegin;
 
  auto check_result_fe_ptr = boost::make_shared<DomainEle>(mField);
  auto petscVec =
      createVectorMPI(mField.get_comm(),
                      (mField.get_comm_rank() == 0) ? LAST_NORM : 0, LAST_NORM);
 
  CHK_THROW_MESSAGE((AddHOOps<SPACE_DIM, SPACE_DIM, SPACE_DIM>::add(
                        check_result_fe_ptr->getOpPtrVector(), {H1})),
                    "Apply transform");
 
  check_result_fe_ptr->getRuleHook = [](int, int, int p) { return p; };
  auto analyticalFunction = [&](double x, double y, double z) {
    return sin(M_PI * x) * sin(M_PI * y);
  };
 
  auto u_ptr = boost::make_shared<VectorDouble>();
 
  check_result_fe_ptr->getOpPtrVector().push_back(
      new OpCalculateScalarFieldValues(field_name, u_ptr));
  auto mValFuncPtr = boost::make_shared<VectorDouble>();
  check_result_fe_ptr->getOpPtrVector().push_back(
      new OpGetTensor0fromFunc(mValFuncPtr, analyticalFunction));
  check_result_fe_ptr->getOpPtrVector().push_back(
      new OpCalcNormL2Tensor0(u_ptr, petscVec, NORM, mValFuncPtr));
  CHKERR VecZeroEntries(petscVec);
  CHKERR DMoFEMLoopFiniteElements(simpleInterface->getDM(),
                                  simpleInterface->getDomainFEName(),
                                  check_result_fe_ptr);
  CHKERR VecAssemblyBegin(petscVec);
  CHKERR VecAssemblyEnd(petscVec);
  MOFEM_LOG_CHANNEL("SELF"); // Clear channel from old tags
  // print norm in general log
  if (mField.get_comm_rank() == 0) {
    const double *norms;
    CHKERR VecGetArrayRead(petscVec, &norms);
    MOFEM_TAG_AND_LOG("SELF", Sev::inform, "Errors")
        << "NORM: " << std::sqrt(norms[NORM]);
    CHKERR VecRestoreArrayRead(petscVec, &norms);
  }
  // compare norm for ctest
  if (atom_test && !mField.get_comm_rank()) {
    const double *t_ptr;
    CHKERR VecGetArrayRead(petscVec, &t_ptr);
    double ref_norm = 2.2e-04;
    double cal_norm;
    switch (atom_test) {
    case 1: // 2D
      cal_norm = sqrt(t_ptr[0]);
      break;
    default:
      SETERRQ(PETSC_COMM_SELF, MOFEM_INVALID_DATA,
               "atom test %d does not exist", atom_test);
    }
    if (cal_norm > ref_norm) {
      SETERRQ(PETSC_COMM_SELF, MOFEM_ATOM_TEST_INVALID,
               "atom test %d failed! Calculated Norm %3.16e is greater than "
               "reference Norm %3.16e",
               atom_test, cal_norm, ref_norm);
    }
    CHKERR VecRestoreArrayRead(petscVec, &t_ptr);
  }
  MoFEMFunctionReturn(0);
}

outputResults()

MoFEMErrorCode Poisson2DHomogeneous::outputResults ( )

private

[Solve system]

[Output results]

Examples

mofem/tutorials/scl-1_poisson_2d_homogeneous/poisson_2d_homogeneous.cpp.

Definition at line 244 of file poisson_2d_homogeneous.cpp.

                                                   {
  MoFEMFunctionBegin;
 
  auto pipeline_mng = mField.getInterface<PipelineManager>();
  pipeline_mng->getDomainLhsFE().reset();
 
  auto post_proc_fe = boost::make_shared<PostProcFaceEle>(mField);
  CHKERR AddHOOps<SPACE_DIM, SPACE_DIM, SPACE_DIM>::add(
      post_proc_fe->getOpPtrVector(), {H1});
 
  auto u_ptr = boost::make_shared<VectorDouble>();
  auto grad_u_ptr = boost::make_shared<MatrixDouble>();
  post_proc_fe->getOpPtrVector().push_back(
      new OpCalculateScalarFieldValues(field_name, u_ptr));
 
  post_proc_fe->getOpPtrVector().push_back(
      new OpCalculateScalarFieldGradient<SPACE_DIM>(field_name, grad_u_ptr));
 
  using OpPPMap = OpPostProcMapInMoab<SPACE_DIM, SPACE_DIM>;
 
  post_proc_fe->getOpPtrVector().push_back(
 
      new OpPPMap(post_proc_fe->getPostProcMesh(),
                  post_proc_fe->getMapGaussPts(),
 
                  OpPPMap::DataMapVec{{"U", u_ptr}},
 
                  OpPPMap::DataMapMat{{"GRAD_U", grad_u_ptr}},
 
                  OpPPMap::DataMapMat{},
 
                  OpPPMap::DataMapMat{}
 
                  )
 
  );
 
  pipeline_mng->getDomainRhsFE() = post_proc_fe;
  CHKERR pipeline_mng->loopFiniteElements();
  CHKERR post_proc_fe->writeFile("out_result.h5m");
 
  MoFEMFunctionReturn(0);
}

readMesh()

MoFEMErrorCode Poisson2DHomogeneous::readMesh ( )

private

[Read mesh]

Examples

mofem/tutorials/scl-1_poisson_2d_homogeneous/poisson_2d_homogeneous.cpp.

Definition at line 66 of file poisson_2d_homogeneous.cpp.

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

runProgram()

MoFEMErrorCode Poisson2DHomogeneous::runProgram

(

)

[Check]

[Run program]

Examples

mofem/tutorials/scl-1_poisson_2d_homogeneous/poisson_2d_homogeneous.cpp.

Definition at line 358 of file poisson_2d_homogeneous.cpp.

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

setIntegrationRules()

MoFEMErrorCode Poisson2DHomogeneous::setIntegrationRules ( )

private

[Assemble system]

[Set integration rules]

Examples

mofem/tutorials/scl-1_poisson_2d_homogeneous/poisson_2d_homogeneous.cpp.

Definition at line 202 of file poisson_2d_homogeneous.cpp.

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

setupProblem()

MoFEMErrorCode Poisson2DHomogeneous::setupProblem ( )

private

[Read mesh]

[Setup problem]

Examples

mofem/tutorials/scl-1_poisson_2d_homogeneous/poisson_2d_homogeneous.cpp.

Definition at line 79 of file poisson_2d_homogeneous.cpp.

                                                  {
  MoFEMFunctionBegin;
  Range domain_ents;
  CHKERR mField.get_moab().get_entities_by_dimension(0, SPACE_DIM, domain_ents,
                                                     true);
  auto get_ents_by_dim = [&](const auto dim) {
    if (dim == SPACE_DIM) {
      return domain_ents;
    } else {
      Range ents;
      if (dim == 0)
        CHKERR mField.get_moab().get_connectivity(domain_ents, ents, true);
      else
        CHKERR mField.get_moab().get_entities_by_dimension(0, dim, ents, true);
      return ents;
    }
  };
 
  // Select base
  auto get_base = [&]() {
    auto domain_ents = get_ents_by_dim(SPACE_DIM);
    if (domain_ents.empty())
      CHK_THROW_MESSAGE(MOFEM_NOT_FOUND, "Empty mesh");
    const auto type = type_from_handle(domain_ents[0]);
    switch (type) {
    case MBQUAD:
      return DEMKOWICZ_JACOBI_BASE;
    case MBHEX:
      return DEMKOWICZ_JACOBI_BASE;
    case MBTRI:
      return AINSWORTH_LEGENDRE_BASE;
    case MBTET:
      return AINSWORTH_LEGENDRE_BASE;
    default:
      CHK_THROW_MESSAGE(MOFEM_NOT_FOUND, "Element type not handled");
    }
    return NOBASE;
  };
  auto base = get_base();
  CHKERR simpleInterface->addDomainField(field_name, H1, base, 1);
 
  int oRder = 3;
  CHKERR PetscOptionsGetInt(PETSC_NULLPTR, "", "-order", &oRder, PETSC_NULLPTR);
  CHKERR PetscOptionsGetInt(PETSC_NULLPTR, "", "-atom_test", &atom_test,
                            PETSC_NULLPTR);
  CHKERR simpleInterface->setFieldOrder(field_name, oRder);
 
  CHKERR simpleInterface->setUp();
 
  MoFEMFunctionReturn(0);
}

solveSystem()

MoFEMErrorCode Poisson2DHomogeneous::solveSystem ( )

private

[Set integration rules]

[Solve system]

Examples

mofem/tutorials/scl-1_poisson_2d_homogeneous/poisson_2d_homogeneous.cpp.

Definition at line 217 of file poisson_2d_homogeneous.cpp.

                                                 {
  MoFEMFunctionBegin;
 
  auto pipeline_mng = mField.getInterface<PipelineManager>();
 
  auto ksp_solver = pipeline_mng->createKSP();
  CHKERR KSPSetFromOptions(ksp_solver);
  CHKERR KSPSetUp(ksp_solver);
 
  // Create RHS and solution vectors
  auto dm = simpleInterface->getDM();
  auto F = createDMVector(dm);
  auto D = vectorDuplicate(F);
 
  // 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 Poisson2DHomogeneous::sourceTermFunction ( const double  x, const double  y, const double  z  )

inlinestaticprivate

Examples

mofem/tutorials/scl-1_poisson_2d_homogeneous/poisson_2d_homogeneous.cpp.

Definition at line 52 of file poisson_2d_homogeneous.cpp.

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

Member Data Documentation

atom_test

int Poisson2DHomogeneous::atom_test = 0

private

Examples

mofem/tutorials/scl-1_poisson_2d_homogeneous/poisson_2d_homogeneous.cpp.

Definition at line 58 of file poisson_2d_homogeneous.cpp.

mField

MoFEM::Interface& Poisson2DHomogeneous::mField

private

Examples

mofem/tutorials/scl-1_poisson_2d_homogeneous/poisson_2d_homogeneous.cpp.

Definition at line 48 of file poisson_2d_homogeneous.cpp.

oRder

int Poisson2DHomogeneous::oRder

private

Examples

mofem/tutorials/scl-1_poisson_2d_homogeneous/poisson_2d_homogeneous.cpp.

Definition at line 50 of file poisson_2d_homogeneous.cpp.

petscVec

SmartPetscObj<Vec> Poisson2DHomogeneous::petscVec

private

Examples

mofem/tutorials/scl-1_poisson_2d_homogeneous/poisson_2d_homogeneous.cpp.

Definition at line 57 of file poisson_2d_homogeneous.cpp.

simpleInterface

Simple* Poisson2DHomogeneous::simpleInterface

private

Examples

mofem/tutorials/scl-1_poisson_2d_homogeneous/poisson_2d_homogeneous.cpp.

Definition at line 46 of file poisson_2d_homogeneous.cpp.

---

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

• tutorials/scl-1_poisson_2d_homogeneous/poisson_2d_homogeneous.cpp