AtomTest Struct Reference

Collaboration diagram for AtomTest:

Classes
struct	CommonData
	Collected data use d by operator to evaluate errors for the test. More...
struct	OpError
	Operator to evaluate errors. More...
struct	OpError< 1 >
struct	OpErrorSkel
struct	OpErrorSkel< 1 >

Public Member Functions
	AtomTest (MoFEM::Interface &m_field)
MoFEMErrorCode	runProblem ()
	[Run programme] More...
	AtomTest (MoFEM::Interface &m_field)
MoFEMErrorCode	runProblem ()
	AtomTest (MoFEM::Interface &m_field)
MoFEMErrorCode	runProblem ()

Private Member Functions
MoFEMErrorCode	readMesh ()
	[Run programme] More...
MoFEMErrorCode	setupProblem ()
	[Read mesh] More...
MoFEMErrorCode	assembleSystem ()
	[Push operators to pipeline] More...
MoFEMErrorCode	solveSystem ()
	[Push operators to pipeline] More...
MoFEMErrorCode	checkResults (boost::function< bool(FEMethod *fe_method_ptr)> test_bit)
	[Postprocess results] More...
MoFEMErrorCode	refineResults ()
	[Solve] More...
MoFEMErrorCode	readMesh ()
	red mesh and randomly refine three times More...
MoFEMErrorCode	setupProblem ()
	add field, and set up problem More...
MoFEMErrorCode	assembleSystem ()
MoFEMErrorCode	solveSystem ()
MoFEMErrorCode	checkResults ()
	[Check results] More...
MoFEMErrorCode	printResults ()
	[Check results] More...
MoFEMErrorCode	readMesh ()
MoFEMErrorCode	setupProblem ()
MoFEMErrorCode	assembleSystem ()
MoFEMErrorCode	solveSystem ()
MoFEMErrorCode	checkResults ()

Private Attributes
MoFEM::Interface &	mField
Simple *	simpleInterface

Static Private Attributes
static ApproxFieldFunction< FIELD_DIM >	approxFunction
static ApproxFieldFunctionDerivative< FIELD_DIM >	divApproxFunction

Detailed Description

Examples

child_and_parent.cpp, hanging_node_approx.cpp, and higher_derivatives.cpp.

Definition at line 57 of file child_and_parent.cpp.

Constructor & Destructor Documentation

AtomTest() [1/3]

AtomTest::AtomTest ( MoFEM::Interface &  m_field )

inline

Definition at line 59 of file child_and_parent.cpp.

: mField(m_field) {}

AtomTest() [2/3]

AtomTest::AtomTest ( MoFEM::Interface &  m_field )

inline

Definition at line 180 of file hanging_node_approx.cpp.

: mField(m_field) {}

AtomTest() [3/3]

AtomTest::AtomTest ( MoFEM::Interface &  m_field )

inline

Definition at line 78 of file higher_derivatives.cpp.

: mField(m_field) {}

Member Function Documentation

assembleSystem() [1/3]

MoFEMErrorCode AtomTest::assembleSystem ( )

private

[Push operators to pipeline]

[Set up problem]

[Push operators to pipeline]

Examples

child_and_parent.cpp, hanging_node_approx.cpp, and higher_derivatives.cpp.

Definition at line 290 of file child_and_parent.cpp.

                                        {
  MoFEMFunctionBegin;
  PipelineManager *pipeline_mng = mField.getInterface<PipelineManager>();
 
  auto rule = [](int, int, int p) -> int { return 2 * p; };
 
  CHKERR pipeline_mng->setDomainLhsIntegrationRule(rule);
  CHKERR pipeline_mng->setDomainRhsIntegrationRule(rule);
 
  auto test_bit_parent = [](FEMethod *fe_ptr) {
    const auto &bit = fe_ptr->numeredEntFiniteElementPtr->getBitRefLevel();
    MOFEM_LOG("SELF", Sev::noisy) << bit << " " << bit.test(0);
    return bit.test(0);
  };
 
  pipeline_mng->getDomainLhsFE()->exeTestHook = test_bit_parent;
  pipeline_mng->getDomainRhsFE()->exeTestHook = test_bit_parent;
 
  auto beta = [](const double, const double, const double) { return 1; };
 
  // Make aliased shared pointer, and create child element
  domainChildLhs = boost::make_shared<DomainEle>(mField);
  domainChildLhs->getRuleHook = rule;
  domainChildLhs->getOpPtrVector().push_back(
      new OpDomainMass(FIELD_NAME, FIELD_NAME, beta));
 
  domainChildRhs = boost::make_shared<DomainEle>(mField);
  domainChildLhs->getRuleHook = rule;
  domainChildRhs->getOpPtrVector().push_back(
      new OpDomainSource(FIELD_NAME, approxFunction));
 
  auto parent_op_lhs = new DomainEleOp(NOSPACE, DomainEleOp::OPSPACE);
  parent_op_lhs->doWorkRhsHook = [&](DataOperator *op_ptr, int side,
                                     EntityType type,
                                     EntitiesFieldData::EntData &data) {
    auto domain_op = static_cast<DomainEleOp *>(op_ptr);
    MoFEMFunctionBegin;
 
    MOFEM_LOG("SELF", Sev::noisy) << "LHS Pipeline FE";
 
    if (!domainChildLhs)
      SETERRQ(PETSC_COMM_SELF, MOFEM_ATOM_TEST_INVALID, "FE not allocated");
 
    auto &bit =
        domain_op->getFEMethod()->numeredEntFiniteElementPtr->getBitRefLevel();
    if (bit == BitRefLevel().set(0)) {
      CHKERR domain_op->loopChildren(domain_op->getFEName(),
                                     domainChildLhs.get(), VERBOSE, Sev::noisy);
    } else {
      CHKERR domain_op->loopThis(domain_op->getFEName(), domainChildLhs.get(),
                                 VERBOSE, Sev::noisy);
    }
    MoFEMFunctionReturn(0);
  };
 
  auto parent_op_rhs = new DomainEleOp(NOSPACE, DomainEleOp::OPSPACE);
  parent_op_rhs->doWorkRhsHook = [&](DataOperator *op_ptr, int side,
                                     EntityType type,
                                     EntitiesFieldData::EntData &data) {
    auto domain_op = static_cast<DomainEleOp *>(op_ptr);
    MoFEMFunctionBegin;
 
    MOFEM_LOG("SELF", Sev::noisy) << "RHS Pipeline FE";
 
    if (!domainChildRhs)
      SETERRQ(PETSC_COMM_SELF, MOFEM_ATOM_TEST_INVALID, "FE not allocated");
 
    auto &bit =
        domain_op->getFEMethod()->numeredEntFiniteElementPtr->getBitRefLevel();
    if (bit == BitRefLevel().set(0)) {
      CHKERR domain_op->loopChildren(domain_op->getFEName(),
                                     domainChildRhs.get(), VERBOSE, Sev::noisy);
    } else if ((bit & BitRefLevel().set(0)).any()) {
      CHKERR domain_op->loopThis(domain_op->getFEName(), domainChildRhs.get(),
                                 VERBOSE, Sev::noisy);
    }
    MoFEMFunctionReturn(0);
  };
 
  pipeline_mng->getOpDomainLhsPipeline().push_back(parent_op_lhs);
  pipeline_mng->getOpDomainRhsPipeline().push_back(parent_op_rhs);
 
  MoFEMFunctionReturn(0);
}

assembleSystem() [2/3]

MoFEMErrorCode AtomTest::assembleSystem ( )

private

assembleSystem() [3/3]

MoFEMErrorCode AtomTest::assembleSystem ( )

private

checkResults() [1/3]

MoFEMErrorCode AtomTest::checkResults ( )

private

[Check results]

Examples

child_and_parent.cpp, hanging_node_approx.cpp, and higher_derivatives.cpp.

Definition at line 578 of file hanging_node_approx.cpp.

                                      {
  MoFEMFunctionBegin;
  PipelineManager *pipeline_mng = mField.getInterface<PipelineManager>();
  pipeline_mng->getDomainLhsFE().reset();
  pipeline_mng->getDomainRhsFE().reset();
  pipeline_mng->getBoundaryRhsFE().reset();
 
  auto rule = [](int, int, int p) -> int { return 2 * p + 1; };
  CHKERR pipeline_mng->setDomainRhsIntegrationRule(rule);
  CHKERR pipeline_mng->setBoundaryRhsIntegrationRule(rule);
  pipeline_mng->getDomainRhsFE()->exeTestHook = test_bit_child;
  pipeline_mng->getBoundaryRhsFE()->exeTestHook = test_bit_child;
 
  auto common_data_ptr = boost::make_shared<CommonData>();
  common_data_ptr->resVec = createDMVector(simpleInterface->getDM());
  common_data_ptr->L2Vec = createVectorMPI(
      mField.get_comm(), (!mField.get_comm_rank()) ? 1 : 0, 1);
  common_data_ptr->approxVals = boost::make_shared<VectorDouble>();
  common_data_ptr->divApproxVals = boost::make_shared<MatrixDouble>();
 
  CHKERR AddHOOps<SPACE_DIM, SPACE_DIM, SPACE_DIM>::add(
      pipeline_mng->getOpDomainRhsPipeline(), {H1});
  set_parent_dofs<DomainParentEle>(mField, pipeline_mng->getDomainRhsFE(),
                                   DomainEleOp::OPSPACE, QUIET, Sev::noisy);
  set_parent_dofs<DomainParentEle>(mField, pipeline_mng->getDomainRhsFE(),
                                   DomainEleOp::OPROW, VERBOSE, Sev::noisy);
 
  pipeline_mng->getOpDomainRhsPipeline().push_back(
      new OpCalculateScalarFieldGradient<SPACE_DIM>(
          FIELD_NAME, common_data_ptr->divApproxVals));
  pipeline_mng->getOpDomainRhsPipeline().push_back(
      new OpCalculateScalarFieldValues(FIELD_NAME,
                                       common_data_ptr->approxVals));
 
  pipeline_mng->getOpDomainRhsPipeline().push_back(
      new OpError<FIELD_DIM>(common_data_ptr));
 
  set_parent_dofs<BoundaryParentEle>(mField, pipeline_mng->getBoundaryRhsFE(),
                                     BoundaryEleOp::OPSPACE, QUIET, Sev::noisy);
  set_parent_dofs<BoundaryParentEle>(mField, pipeline_mng->getBoundaryRhsFE(),
                                     BoundaryEleOp::OPROW, VERBOSE, Sev::noisy);
  pipeline_mng->getOpBoundaryRhsPipeline().push_back(
      new OpCalculateScalarFieldValues(FIELD_NAME,
                                       common_data_ptr->approxVals));
  pipeline_mng->getOpBoundaryRhsPipeline().push_back(
      new OpErrorSkel<FIELD_DIM>(common_data_ptr));
 
  CHKERR VecZeroEntries(common_data_ptr->L2Vec);
  CHKERR VecZeroEntries(common_data_ptr->resVec);
 
  CHKERR pipeline_mng->loopFiniteElements();
 
  CHKERR VecAssemblyBegin(common_data_ptr->L2Vec);
  CHKERR VecAssemblyEnd(common_data_ptr->L2Vec);
  CHKERR VecAssemblyBegin(common_data_ptr->resVec);
  CHKERR VecAssemblyEnd(common_data_ptr->resVec);
  double nrm2;
  CHKERR VecNorm(common_data_ptr->resVec, NORM_2, &nrm2);
  const double *array;
  CHKERR VecGetArrayRead(common_data_ptr->L2Vec, &array);
  MOFEM_LOG_C("WORLD", Sev::inform, "Error %6.4e Vec norm %6.4e\n",
              std::sqrt(array[0]), nrm2);
 
  constexpr double eps = 1e-8;
  if (nrm2 > eps)
    SETERRQ1(PETSC_COMM_SELF, MOFEM_ATOM_TEST_INVALID,
             "Not converged solution err = %6.4e", nrm2);
  if (std::sqrt(array[0]) > eps)
    SETERRQ1(PETSC_COMM_SELF, MOFEM_ATOM_TEST_INVALID,
             "Error in approximation err = %6.4e", std::sqrt(array[0]));
 
  CHKERR VecRestoreArrayRead(common_data_ptr->L2Vec, &array);
 
  MoFEMFunctionReturn(0);
}

checkResults() [2/3]

MoFEMErrorCode AtomTest::checkResults ( )

private

checkResults() [3/3]

MoFEMErrorCode AtomTest::checkResults ( boost::function< bool(FEMethod *fe_method_ptr)>  test_bit )

private

[Postprocess results]

[Check results]

Definition at line 523 of file child_and_parent.cpp.

                                                           {
  MoFEMFunctionBegin;
  PipelineManager *pipeline_mng = mField.getInterface<PipelineManager>();
  pipeline_mng->getDomainLhsFE().reset();
  pipeline_mng->getDomainRhsFE().reset();
  pipeline_mng->getBoundaryRhsFE().reset();
 
  auto rule = [](int, int, int p) -> int { return 2 * p + 1; };
  CHKERR pipeline_mng->setDomainRhsIntegrationRule(rule);
  pipeline_mng->getDomainRhsFE()->exeTestHook = test_bit;
 
  auto common_data_ptr = boost::make_shared<CommonData>();
  common_data_ptr->resVec = createDMVector(simpleInterface->getDM());
  common_data_ptr->L2Vec = createVectorMPI(
      mField.get_comm(), (!mField.get_comm_rank()) ? 1 : 0, 1);
  common_data_ptr->approxVals = boost::make_shared<VectorDouble>();
 
  pipeline_mng->getOpDomainRhsPipeline().push_back(
      new OpCalculateScalarFieldValues(FIELD_NAME,
                                       common_data_ptr->approxVals));
  pipeline_mng->getOpDomainRhsPipeline().push_back(
      new OpError<FIELD_DIM>(common_data_ptr));
 
  CHKERR VecZeroEntries(common_data_ptr->L2Vec);
  CHKERR VecZeroEntries(common_data_ptr->resVec);
 
  CHKERR pipeline_mng->loopFiniteElements();
 
  CHKERR VecAssemblyBegin(common_data_ptr->L2Vec);
  CHKERR VecAssemblyEnd(common_data_ptr->L2Vec);
  CHKERR VecAssemblyBegin(common_data_ptr->resVec);
  CHKERR VecAssemblyEnd(common_data_ptr->resVec);
  double nrm2;
  CHKERR VecNorm(common_data_ptr->resVec, NORM_2, &nrm2);
  const double *array;
  CHKERR VecGetArrayRead(common_data_ptr->L2Vec, &array);
  MOFEM_LOG_C("WORLD", Sev::inform, "Error %6.4e Vec norm %6.4e\n",
              std::sqrt(array[0]), nrm2);
  CHKERR VecRestoreArrayRead(common_data_ptr->L2Vec, &array);
 
  constexpr double eps = 1e-8;
  if (nrm2 > eps)
    SETERRQ1(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
             "Not converged solution err = %6.4e", nrm2);
  MoFEMFunctionReturn(0);
}

printResults()

MoFEMErrorCode AtomTest::printResults ( )

private

[Check results]

Examples

hanging_node_approx.cpp.

Definition at line 655 of file hanging_node_approx.cpp.

                                      {
  MoFEMFunctionBegin;
  PipelineManager *pipeline_mng = mField.getInterface<PipelineManager>();
  pipeline_mng->getDomainLhsFE().reset();
  pipeline_mng->getDomainRhsFE().reset();
 
  auto rule = [](int, int, int p) -> int { return -1; };
  CHKERR pipeline_mng->setDomainRhsIntegrationRule(rule);
 
  static_cast<ForcesAndSourcesCore *>(pipeline_mng->getDomainRhsFE().get())
      ->setRuleHook = [](ForcesAndSourcesCore *fe_raw_ptr, int order_row,
                         int order_col, int order_data) -> MoFEMErrorCode {
    MoFEMFunctionBeginHot;
    fe_raw_ptr->gaussPts.resize(3, 3);
    fe_raw_ptr->gaussPts(0, 0) = 0;
    fe_raw_ptr->gaussPts(1, 0) = 0;
    fe_raw_ptr->gaussPts(2, 0) = 0;
    fe_raw_ptr->gaussPts(0, 1) = 1;
    fe_raw_ptr->gaussPts(1, 1) = 0;
    fe_raw_ptr->gaussPts(2, 1) = 0;
    fe_raw_ptr->gaussPts(0, 2) = 0;
    fe_raw_ptr->gaussPts(1, 2) = 1;
    fe_raw_ptr->gaussPts(2, 2) = 0;
    MoFEMFunctionReturnHot(0);
  };
 
  auto field_op_row = new ForcesAndSourcesCore::UserDataOperator(
      FIELD_NAME, DomainEleOp::OPROW);
 
  auto approx_vals = boost::make_shared<VectorDouble>();
 
  auto &moab = mField.get_moab();
  Tag th;
  double def_val[] = {0};
  CHKERR moab.tag_get_handle("FIELD", 1, MB_TYPE_DOUBLE, th,
                             MB_TAG_CREAT | MB_TAG_SPARSE, &def_val);
 
  field_op_row->doWorkRhsHook = [&](DataOperator *base_op_ptr, int side,
                                    EntityType type,
                                    EntitiesFieldData::EntData &data) {
    MoFEMFunctionBegin;
    if (type == MBVERTEX) {
      auto op_ptr =
          static_cast<FaceElementForcesAndSourcesCore::UserDataOperator *>(
              base_op_ptr);
      auto t_field = getFTensor0FromVec(*approx_vals);
      auto nb_gauss_pts = op_ptr->getGaussPts().size2();
      if (nb_gauss_pts != 3)
        SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
                "Should be three guass pts.");
      auto conn = op_ptr->getConn();
      for (auto gg = 0; gg != nb_gauss_pts; ++gg) {
        const double v = t_field;
        CHKERR moab.tag_set_data(th, &conn[gg], 1, &v);
        ++t_field;
      }
    }
    MoFEMFunctionReturn(0);
  };
 
  set_parent_dofs<DomainParentEle>(mField, pipeline_mng->getDomainRhsFE(),
                                   DomainEleOp::OPSPACE, VERBOSE, Sev::noisy);
  set_parent_dofs<DomainParentEle>(mField, pipeline_mng->getDomainRhsFE(),
                                   DomainEleOp::OPROW, VERBOSE, Sev::noisy);
  pipeline_mng->getOpDomainRhsPipeline().push_back(
      new OpCalculateScalarFieldValues(FIELD_NAME, approx_vals));
  pipeline_mng->getOpDomainRhsPipeline().push_back(field_op_row);
  CHKERR pipeline_mng->loopFiniteElements();
 
  CHKERR mField.getInterface<BitRefManager>()->writeBitLevelByType(
      bit(nb_ref_levels), BitRefLevel().set(), MBTRI, "out.vtk", "VTK", "");
 
  MoFEMFunctionReturn(0);
}

readMesh() [1/3]

MoFEMErrorCode AtomTest::readMesh ( )

private

[Run programme]

[Read mesh]

Examples

child_and_parent.cpp, hanging_node_approx.cpp, and higher_derivatives.cpp.

Definition at line 208 of file child_and_parent.cpp.

                                  {
  MoFEMFunctionBegin;
 
  CHKERR mField.getInterface(simpleInterface);
  CHKERR simpleInterface->getOptions();
  CHKERR simpleInterface->loadFile();
 
  MOFEM_LOG("WORLD", Sev::verbose) << "Dim " << simpleInterface->getDim();
 
  auto bit_level0 = simpleInterface->getBitRefLevel();
 
  auto &moab = mField.get_moab();
 
  auto refine_mesh = [&](auto bit_level1) {
    MoFEMFunctionBegin;
 
    auto refine = mField.getInterface<MeshRefinement>();
 
    auto meshset_level0_ptr = get_temp_meshset_ptr(moab);
    CHKERR mField.getInterface<BitRefManager>()->getEntitiesByRefLevel(
        bit_level0, BitRefLevel().set(), *meshset_level0_ptr);
 
    // random mesh refinement
    auto meshset_ref_edges_ptr = get_temp_meshset_ptr(moab);
    Range edges_to_refine;
    CHKERR moab.get_entities_by_type(*meshset_level0_ptr, MBEDGE,
                                     edges_to_refine);
    int ii = 0;
    for (Range::iterator eit = edges_to_refine.begin();
         eit != edges_to_refine.end(); eit++, ii++) {
      int numb = ii % 2;
      if (numb == 0) {
        CHKERR moab.add_entities(*meshset_ref_edges_ptr, &*eit, 1);
      }
    }
    CHKERR refine->addVerticesInTheMiddleOfEdges(*meshset_ref_edges_ptr,
                                                 bit_level1, false, VERBOSE);
    if (simpleInterface->getDim() == 3) {
      CHKERR refine->refineTets(*meshset_level0_ptr, bit_level1, VERBOSE);
    } else if (simpleInterface->getDim() == 2) {
      CHKERR refine->refineTris(*meshset_level0_ptr, bit_level1, VERBOSE);
    } else {
      SETERRQ(PETSC_COMM_WORLD, MOFEM_ATOM_TEST_INVALID,
              "Dimension not handled by test");
    }
 
    MoFEMFunctionReturn(0);
  };
 
  BitRefLevel bit_level1;
  bit_level1.set(1);
  CHKERR refine_mesh(bit_level1);
  simpleInterface->getBitRefLevel() = BitRefLevel().set();
  simpleInterface->getBitRefLevelMask() = BitRefLevel().set();
 
  MoFEMFunctionReturn(0);
}

readMesh() [2/3]

MoFEMErrorCode AtomTest::readMesh ( )

private

red mesh and randomly refine three times

Returns

MoFEMErrorCode

readMesh() [3/3]

MoFEMErrorCode AtomTest::readMesh ( )

private

refineResults()

MoFEMErrorCode AtomTest::refineResults ( )

private

[Solve]

Examples

child_and_parent.cpp.

Definition at line 399 of file child_and_parent.cpp.

                                       {
  MoFEMFunctionBegin;
 
  auto &moab = mField.get_moab();
 
  auto bit_level0 = BitRefLevel().set(0);
  auto bit_level1 = BitRefLevel().set(1);
  auto bit_level2 = BitRefLevel().set(2);
 
  auto refine_mesh = [&]() {
    MoFEMFunctionBegin;
 
    auto refine = mField.getInterface<MeshRefinement>();
 
    auto meshset_level1_ptr = get_temp_meshset_ptr(moab);
    CHKERR mField.getInterface<BitRefManager>()->getEntitiesByDimAndRefLevel(
        bit_level1, BitRefLevel().set(), simpleInterface->getDim(),
        *meshset_level1_ptr);
 
    // random mesh refinement
    auto meshset_ref_edges_ptr = get_temp_meshset_ptr(moab);
    Range edges_to_refine;
    CHKERR mField.getInterface<BitRefManager>()->getEntitiesByTypeAndRefLevel(
        bit_level1, BitRefLevel().set(), MBEDGE, edges_to_refine);
 
    CHKERR refine->addVerticesInTheMiddleOfEdges(edges_to_refine, bit_level2,
                                                 VERBOSE);
    if (simpleInterface->getDim() == 3) {
      CHKERR refine->refineTets(*meshset_level1_ptr, bit_level2, VERBOSE);
    } else if (simpleInterface->getDim() == 2) {
      CHKERR refine->refineTris(*meshset_level1_ptr, bit_level2, VERBOSE);
    } else {
      SETERRQ(PETSC_COMM_WORLD, MOFEM_ATOM_TEST_INVALID,
              "Dimension not handled by test");
    }
 
    Range meshsets;
    CHKERR moab.get_entities_by_type(0, MBENTITYSET, meshsets, true);
    for (auto m : meshsets) {
      CHKERR mField.getInterface<BitRefManager>()
          ->updateMeshsetByEntitiesChildren(m, bit_level2, m, MBMAXTYPE, false);
    }
 
    MoFEMFunctionReturn(0);
  };
 
  CHKERR refine_mesh();
 
  simpleInterface->getBitRefLevel() = bit_level1 | bit_level2;
  simpleInterface->getBitRefLevelMask() = BitRefLevel().set();
 
  CHKERR simpleInterface->reSetUp();
 
  CHKERR mField.getInterface<ProblemsManager>()->removeDofsOnEntities(
      simpleInterface->getProblemName(), FIELD_NAME, BitRefLevel().set(),
      bit_level0 | bit_level1);
 
  auto project_data = [&]() {
    MoFEMFunctionBegin;
 
    PipelineManager *pipeline_mng = mField.getInterface<PipelineManager>();
 
    pipeline_mng->getDomainLhsFE().reset();
    pipeline_mng->getDomainRhsFE().reset();
    pipeline_mng->getBoundaryRhsFE().reset();
 
    auto rule = [](int, int, int p) -> int { return 2 * p; };
 
    CHKERR pipeline_mng->setDomainLhsIntegrationRule(rule);
    CHKERR pipeline_mng->setDomainRhsIntegrationRule(rule);
    CHKERR pipeline_mng->setBoundaryRhsIntegrationRule(rule);
 
    auto test_bit_ref = [](FEMethod *fe_ptr) {
      const auto &bit = fe_ptr->numeredEntFiniteElementPtr->getBitRefLevel();
      MOFEM_LOG("SELF", Sev::noisy) << "ref : " << bit << " " << bit.test(2);
      return bit.test(2);
    };
 
    pipeline_mng->getDomainLhsFE()->exeTestHook = test_bit_ref;
    pipeline_mng->getDomainRhsFE()->exeTestHook = test_bit_ref;
    pipeline_mng->getBoundaryRhsFE()->exeTestHook = test_bit_ref;
 
    auto beta = [](const double, const double, const double) { return 1; };
    auto field_vals_ptr = boost::make_shared<VectorDouble>();
 
    auto domainParentRhs = boost::make_shared<DomainParentEle>(mField);
    domainParentRhs->getOpPtrVector().push_back(
        new OpCalculateScalarFieldValues(FIELD_NAME, field_vals_ptr));
 
    pipeline_mng->getOpDomainLhsPipeline().push_back(
        new OpDomainMass(FIELD_NAME, FIELD_NAME, beta));
    pipeline_mng->getOpDomainRhsPipeline().push_back(
        new OpRunParent(domainParentRhs, bit_level2, bit_level2,
                        domainParentRhs, bit_level2, BitRefLevel().set()));
 
    using OpDomainTimesScalarField = FormsIntegrators<DomainEleOp>::Assembly<
        PETSC>::LinearForm<GAUSS>::OpBaseTimesScalar<1>;
    pipeline_mng->getOpDomainRhsPipeline().push_back(
        new OpDomainTimesScalarField(FIELD_NAME, field_vals_ptr, beta));
 
    pipeline_mng->getOpDomainRhsPipeline().push_back(
        new OpCheckGaussCoords<DomainEleOp, DomainParentEle>());
 
    pipeline_mng->getOpBoundaryRhsPipeline().push_back(
        new OpCheckGaussCoords<BoundaryEleOp, BoundaryParentEle>());
 
    CHKERR solveSystem();
 
    simpleInterface->getBitRefLevel() = bit_level2;
    simpleInterface->getBitRefLevelMask() = BitRefLevel().set();
    CHKERR simpleInterface->reSetUp();
 
    CHKERR checkResults([](FEMethod *fe_ptr) { return true; });
 
    MoFEMFunctionReturn(0);
  };
 
  CHKERR project_data();
 
  MoFEMFunctionReturn(0);
}

runProblem() [1/3]

MoFEMErrorCode AtomTest::runProblem

(

)

[Run programme]

Examples

child_and_parent.cpp, hanging_node_approx.cpp, and higher_derivatives.cpp.

Definition at line 188 of file child_and_parent.cpp.

                                    {
  MoFEMFunctionBegin;
  CHKERR readMesh();
  CHKERR setupProblem();
  CHKERR assembleSystem();
  CHKERR solveSystem();
 
  auto test_bit_child = [](FEMethod *fe_ptr) {
    const auto &bit = fe_ptr->numeredEntFiniteElementPtr->getBitRefLevel();
    MOFEM_LOG("SELF", Sev::noisy) << bit << " " << bit.test(0);
    return bit.test(1);
  };
 
  CHKERR checkResults(test_bit_child);
  CHKERR refineResults();
  MoFEMFunctionReturn(0);
}

runProblem() [2/3]

MoFEMErrorCode AtomTest::runProblem

(

)

runProblem() [3/3]

MoFEMErrorCode AtomTest::runProblem

(

)

setupProblem() [1/3]

MoFEMErrorCode AtomTest::setupProblem ( )

private

[Read mesh]

[Set up problem]

Examples

child_and_parent.cpp, hanging_node_approx.cpp, and higher_derivatives.cpp.

Definition at line 268 of file child_and_parent.cpp.

                                      {
  MoFEMFunctionBegin;
  // Add field
  CHKERR simpleInterface->addDomainField(FIELD_NAME, H1,
                                         AINSWORTH_LEGENDRE_BASE, FIELD_DIM);
  CHKERR simpleInterface->addBoundaryField(FIELD_NAME, H1,
                                           AINSWORTH_LEGENDRE_BASE, FIELD_DIM);
  constexpr int order = 4;
  CHKERR simpleInterface->setFieldOrder(FIELD_NAME, order);
  CHKERR simpleInterface->setUp();
 
  CHKERR mField.getInterface<ProblemsManager>()->removeDofsOnEntities(
      simpleInterface->getProblemName(), FIELD_NAME, BitRefLevel().set(0),
      BitRefLevel().set(0));
 
  MoFEMFunctionReturn(0);
}

setupProblem() [2/3]

MoFEMErrorCode AtomTest::setupProblem ( )

private

add field, and set up problem

Returns

MoFEMErrorCode

setupProblem() [3/3]

MoFEMErrorCode AtomTest::setupProblem ( )

private

solveSystem() [1/3]

MoFEMErrorCode AtomTest::solveSystem ( )

private

[Push operators to pipeline]

[Solve]

Examples

child_and_parent.cpp, hanging_node_approx.cpp, and higher_derivatives.cpp.

Definition at line 377 of file child_and_parent.cpp.

                                     {
  MoFEMFunctionBegin;
  PipelineManager *pipeline_mng = mField.getInterface<PipelineManager>();
 
  MOFEM_LOG("WORLD", Sev::inform) << "Solve problem";
 
  auto solver = pipeline_mng->createKSP();
  CHKERR KSPSetFromOptions(solver);
  CHKERR KSPSetUp(solver);
 
  auto dm = simpleInterface->getDM();
  auto D = createDMVector(dm);
  auto F = vectorDuplicate(D);
 
  CHKERR KSPSolve(solver, F, D);
  CHKERR VecGhostUpdateBegin(D, INSERT_VALUES, SCATTER_FORWARD);
  CHKERR VecGhostUpdateEnd(D, INSERT_VALUES, SCATTER_FORWARD);
  CHKERR DMoFEMMeshToLocalVector(dm, D, INSERT_VALUES, SCATTER_REVERSE);
  MoFEMFunctionReturn(0);
}

solveSystem() [2/3]

MoFEMErrorCode AtomTest::solveSystem ( )

private

solveSystem() [3/3]

MoFEMErrorCode AtomTest::solveSystem ( )

private

Member Data Documentation

approxFunction

ApproxFieldFunction< FIELD_DIM > AtomTest::approxFunction

staticprivate

Initial value:

=
    ApproxFieldFunction<FIELD_DIM>()

Examples

child_and_parent.cpp, and hanging_node_approx.cpp.

Definition at line 67 of file child_and_parent.cpp.

divApproxFunction

ApproxFieldFunctionDerivative< FIELD_DIM > AtomTest::divApproxFunction

staticprivate

Initial value:

=
    ApproxFieldFunctionDerivative<FIELD_DIM>()

Examples

hanging_node_approx.cpp.

Definition at line 189 of file hanging_node_approx.cpp.

mField

MoFEM::Interface & AtomTest::mField

private

Examples

child_and_parent.cpp, hanging_node_approx.cpp, and higher_derivatives.cpp.

Definition at line 64 of file child_and_parent.cpp.

simpleInterface

Simple * AtomTest::simpleInterface

private

Examples

child_and_parent.cpp, hanging_node_approx.cpp, and higher_derivatives.cpp.

Definition at line 65 of file child_and_parent.cpp.

---

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

• atom_tests/child_and_parent.cpp
• atom_tests/hanging_node_approx.cpp
• atom_tests/higher_derivatives.cpp