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 ()
	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 ()
MoFEMErrorCode	setupProblem ()
MoFEMErrorCode	assembleSystem ()
MoFEMErrorCode	solveSystem ()
MoFEMErrorCode	checkResults ()
	[Check results] 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 ()
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, dg_projection.cpp, hanging_node_approx.cpp, and higher_derivatives.cpp.

Definition at line 57 of file child_and_parent.cpp.

Constructor & Destructor Documentation

AtomTest() [1/4]

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

inline

Definition at line 59 of file child_and_parent.cpp.

: mField(m_field) {}

AtomTest() [2/4]

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

inline

Definition at line 56 of file dg_projection.cpp.

: mField(m_field) {}

AtomTest() [3/4]

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

inline

Definition at line 180 of file hanging_node_approx.cpp.

: mField(m_field) {}

AtomTest() [4/4]

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

inline

Definition at line 78 of file higher_derivatives.cpp.

: mField(m_field) {}

Member Function Documentation

assembleSystem() [1/4]

MoFEMErrorCode AtomTest::assembleSystem ( )

private

assembleSystem() [2/4]

MoFEMErrorCode AtomTest::assembleSystem ( )

private

[Push operators to pipeline]

[Set up problem]

[Push operators to pipeline]

Examples

child_and_parent.cpp, dg_projection.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() [3/4]

MoFEMErrorCode AtomTest::assembleSystem ( )

private

assembleSystem() [4/4]

MoFEMErrorCode AtomTest::assembleSystem ( )

private

checkResults() [1/4]

MoFEMErrorCode AtomTest::checkResults ( )

private

[Check results]

Examples

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

Definition at line 213 of file dg_projection.cpp.

                                      {
  MoFEMFunctionBegin;
  auto simple = mField.getInterface<Simple>();
  auto pipeline_mng = mField.getInterface<PipelineManager>();
  pipeline_mng->getDomainLhsFE().reset();
  pipeline_mng->getDomainRhsFE().reset();
  pipeline_mng->getOpDomainRhsPipeline().clear();
 
  auto rule = [](int, int, int p) -> int { return 2 * p + 1; };
  CHKERR pipeline_mng->setDomainRhsIntegrationRule(
      rule); // set integration rule
 
  auto entity_data_l2 = boost::make_shared<EntitiesFieldData>(
      MBENTITYSET); // entity data shared between
                    // physical and post proc
                    // elements
  auto mass_ptr = boost::make_shared<MatrixDouble>(); // integrated mass matrix
                                                      // of post proc element
  auto coeffs_ptr =
      boost::make_shared<MatrixDouble>(); // vector of coeffs shared between
                                          // physical and post proc elements
  auto data_ptr =
      boost::make_shared<MatrixDouble>(); // data stored at integration points
                                          // of the physical element and
                                          // evaluated at integration points of
                                          // the post proc element
 
  auto op_this =
      new OpLoopThis<DomainEle>(mField, simple->getDomainFEName(), Sev::noisy);
  pipeline_mng->getOpDomainRhsPipeline().push_back(op_this); // 1
  pipeline_mng->getOpDomainRhsPipeline().push_back(new OpDGProjectionEvaluation(
      data_ptr, coeffs_ptr, entity_data_l2, AINSWORTH_LEGENDRE_BASE,
      L2)); // 5
  pipeline_mng->getOpDomainRhsPipeline().push_back(
      new OpError(data_ptr)); // 6
 
  auto fe_physics_ptr = op_this->getThisFEPtr();
  fe_physics_ptr->getRuleHook = [](int, int, int p) { return 2 * p; };
 
  fe_physics_ptr->getOpPtrVector().push_back(new OpDGProjectionMassMatrix(
      order, mass_ptr, entity_data_l2, AINSWORTH_LEGENDRE_BASE, L2)); // 2
  fe_physics_ptr->getOpPtrVector().push_back(
      new OpCalculateVectorFieldValues<FIELD_DIM>(FIELD_NAME,
                                                  data_ptr)); // 3
  fe_physics_ptr->getOpPtrVector().push_back(
      new OpDGProjectionCoefficients(data_ptr, coeffs_ptr, mass_ptr,
                                     entity_data_l2, AINSWORTH_LEGENDRE_BASE,
                                     L2)); // 4
 
  CHKERR pipeline_mng->loopFiniteElements();
 
  MoFEMFunctionReturn(0);
}

checkResults() [2/4]

MoFEMErrorCode AtomTest::checkResults ( )

private

checkResults() [3/4]

MoFEMErrorCode AtomTest::checkResults ( )

private

checkResults() [4/4]

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/4]

MoFEMErrorCode AtomTest::readMesh ( )

private

readMesh() [2/4]

MoFEMErrorCode AtomTest::readMesh ( )

private

[Run programme]

[Read mesh]

Examples

child_and_parent.cpp, dg_projection.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() [3/4]

MoFEMErrorCode AtomTest::readMesh ( )

private

readMesh() [4/4]

MoFEMErrorCode AtomTest::readMesh ( )

private

red mesh and randomly refine three times

Returns

MoFEMErrorCode

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/4]

MoFEMErrorCode AtomTest::runProblem

(

)

runProblem() [2/4]

MoFEMErrorCode AtomTest::runProblem

(

)

[Run programme]

Examples

child_and_parent.cpp, dg_projection.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() [3/4]

MoFEMErrorCode AtomTest::runProblem

(

)

runProblem() [4/4]

MoFEMErrorCode AtomTest::runProblem

(

)

setupProblem() [1/4]

MoFEMErrorCode AtomTest::setupProblem ( )

private

setupProblem() [2/4]

MoFEMErrorCode AtomTest::setupProblem ( )

private

[Read mesh]

[Set up problem]

Examples

child_and_parent.cpp, dg_projection.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() [3/4]

MoFEMErrorCode AtomTest::setupProblem ( )

private

setupProblem() [4/4]

MoFEMErrorCode AtomTest::setupProblem ( )

private

add field, and set up problem

Returns

MoFEMErrorCode

solveSystem() [1/4]

MoFEMErrorCode AtomTest::solveSystem ( )

private

solveSystem() [2/4]

MoFEMErrorCode AtomTest::solveSystem ( )

private

[Push operators to pipeline]

[Solve]

Examples

child_and_parent.cpp, dg_projection.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() [3/4]

MoFEMErrorCode AtomTest::solveSystem ( )

private

solveSystem() [4/4]

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

Definition at line 64 of file child_and_parent.cpp.

simpleInterface

Simple * AtomTest::simpleInterface

private

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/dg_projection.cpp
• atom_tests/hanging_node_approx.cpp
• atom_tests/higher_derivatives.cpp