scalar_check_approximation.cpp File Reference

#include <MoFEM.hpp>

Go to the source code of this file.

Classes
struct	ApproxFunctionsImpl< DIM >
struct	ElementsAndOps< DIM >
struct	ApproxFunctionsImpl< 2 >
struct	ApproxFunctionsImpl< 3 >
struct	OpValsDiffVals
struct	OpCheckValsDiffVals

Typedefs
using	DomainEle = PipelineManager::ElementsAndOpsByDim<SPACE_DIM>::DomainEle
using	BoundaryEle
using	EleOnSide = PipelineManager::ElementsAndOpsByDim<SPACE_DIM>::FaceSideEle
using	ApproxFunctions = ApproxFunctionsImpl<SPACE_DIM>

Functions
int	main (int argc, char *argv[])

Variables
static char	help [] = "...\n\n"
static int	approx_order = 4
constexpr int	SPACE_DIM

Typedef Documentation

ApproxFunctions

using ApproxFunctions = ApproxFunctionsImpl<SPACE_DIM>

Definition at line 96 of file scalar_check_approximation.cpp.

BoundaryEle

using BoundaryEle

Initial value:

 
    PipelineManager::ElementsAndOpsByDim<SPACE_DIM>::BoundaryEle

Definition at line 25 of file scalar_check_approximation.cpp.

DomainEle

using DomainEle = PipelineManager::ElementsAndOpsByDim<SPACE_DIM>::DomainEle

Definition at line 24 of file scalar_check_approximation.cpp.

EleOnSide

using EleOnSide = PipelineManager::ElementsAndOpsByDim<SPACE_DIM>::FaceSideEle

Definition at line 27 of file scalar_check_approximation.cpp.

Function Documentation

main()

int main	(	int	argc,
		char *	argv[] )

Definition at line 284 of file scalar_check_approximation.cpp.

                                 {
 
  MoFEM::Core::Initialize(&argc, &argv, (char *)0, help);
 
  try {
 
    DMType dm_name = "DMMOFEM";
    CHKERR DMRegister_MoFEM(dm_name);
 
    moab::Core mb_instance;
    moab::Interface &moab = mb_instance;
 
    // Add logging channel for example
    auto core_log = logging::core::get();
    core_log->add_sink(
        LogManager::createSink(LogManager::getStrmWorld(), "AT"));
    LogManager::setLog("AT");
    MOFEM_LOG_TAG("AT", "atom_test");
 
    // Create MoFEM instance
    MoFEM::Core core(moab);
    MoFEM::Interface &m_field = core;
 
    Simple *simple = m_field.getInterface<Simple>();
    PipelineManager *pipeline_mng = m_field.getInterface<PipelineManager>();
    CHKERR simple->getOptions();
 
    simple->getAddBoundaryFE() = true;
 
    CHKERR simple->loadFile("", "");
 
    // Declare elements
    enum bases {
      AINSWORTH,
      AINSWORTH_LOBATTO,
      DEMKOWICZ,
      BERNSTEIN,
      LASBASETOP
    };
    const char *list_bases[] = {"ainsworth", "ainsworth_lobatto", "demkowicz",
                                "bernstein"};
    PetscBool flg;
    PetscInt choice_base_value = AINSWORTH;
    CHKERR PetscOptionsGetEList(PETSC_NULL, NULL, "-base", list_bases,
                                LASBASETOP, &choice_base_value, &flg);
 
    if (flg != PETSC_TRUE)
      SETERRQ(PETSC_COMM_SELF, MOFEM_IMPOSSIBLE_CASE, "base not set");
    FieldApproximationBase base = AINSWORTH_LEGENDRE_BASE;
    if (choice_base_value == AINSWORTH)
      base = AINSWORTH_LEGENDRE_BASE;
    if (choice_base_value == AINSWORTH_LOBATTO)
      base = AINSWORTH_LOBATTO_BASE;
    else if (choice_base_value == DEMKOWICZ)
      base = DEMKOWICZ_JACOBI_BASE;
    else if (choice_base_value == BERNSTEIN)
      base = AINSWORTH_BERNSTEIN_BEZIER_BASE;
 
    enum spaces { H1SPACE, L2SPACE, LASBASETSPACE };
    const char *list_spaces[] = {"h1", "l2"};
    PetscInt choice_space_value = H1SPACE;
    CHKERR PetscOptionsGetEList(PETSC_NULL, NULL, "-space", list_spaces,
                                LASBASETSPACE, &choice_space_value, &flg);
    if (flg != PETSC_TRUE)
      SETERRQ(PETSC_COMM_SELF, MOFEM_IMPOSSIBLE_CASE, "space not set");
    FieldSpace space = H1;
    if (choice_space_value == H1SPACE)
      space = H1;
    else if (choice_space_value == L2SPACE)
      space = L2;
 
    CHKERR PetscOptionsGetInt(PETSC_NULL, "", "-order", &approx_order,
                              PETSC_NULL);
 
    CHKERR simple->addDomainField("FIELD1", space, base, 1);
    CHKERR simple->setFieldOrder("FIELD1", approx_order);
 
    Range edges, faces;
    CHKERR moab.get_entities_by_dimension(0, 1, edges);
    CHKERR moab.get_entities_by_dimension(0, 2, faces);
 
    if (choice_base_value != BERNSTEIN) {
      Range rise_order;
 
      int i = 0;
      for (auto e : edges) {
        if (!(i % 2)) {
          rise_order.insert(e);
        }
        ++i;
      }
 
      for (auto f : faces) {
        if (!(i % 3)) {
          rise_order.insert(f);
        }
        ++i;
      }
 
      Range rise_twice;
      for (auto e : rise_order) {
        if (!(i % 2)) {
          rise_twice.insert(e);
        }
        ++i;
      }
 
      CHKERR simple->setFieldOrder("FIELD1", approx_order + 1, &rise_order);
 
      CHKERR simple->setFieldOrder("FIELD1", approx_order + 2, &rise_twice);
    }
 
    CHKERR simple->defineFiniteElements();
 
    auto volume_adj = [](moab::Interface &moab, const Field &field,
                         const EntFiniteElement &fe,
                         std::vector<EntityHandle> &adjacency) {
      MoFEMFunctionBegin;
      EntityHandle fe_ent = fe.getEnt();
      switch (field.getSpace()) {
      case H1:
        CHKERR moab.get_connectivity(&fe_ent, 1, adjacency, true);
      case HCURL:
        CHKERR moab.get_adjacencies(&fe_ent, 1, 1, false, adjacency,
                                    moab::Interface::UNION);
      case HDIV:
      case L2:
        CHKERR moab.get_adjacencies(&fe_ent, 1, 2, false, adjacency,
                                    moab::Interface::UNION);
        adjacency.push_back(fe_ent);
        // build side table
        for (auto ent : adjacency)
          fe.getSideNumberPtr(ent);
        break;
      case NOFIELD: {
        CHKERR moab.get_entities_by_handle(field.getMeshset(), adjacency,
                                           false);
        for (auto ent : adjacency) {
          const_cast<SideNumber_multiIndex &>(fe.getSideNumberTable())
              .insert(
                  boost::shared_ptr<SideNumber>(new SideNumber(ent, -1, 0, 0)));
        }
      } break;
      default:
        SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED,
                "this field is not implemented for TRI finite element");
      }
 
      MoFEMFunctionReturn(0);
    };
 
    CHKERR m_field.modify_finite_element_adjacency_table(
        simple->getDomainFEName(), MBTET, volume_adj);
    CHKERR m_field.modify_finite_element_adjacency_table(
        simple->getDomainFEName(), MBHEX, volume_adj);
 
    CHKERR simple->defineProblem(PETSC_TRUE);
    CHKERR simple->buildFields();
    CHKERR simple->buildFiniteElements();
    CHKERR simple->buildProblem();
 
    auto dm = simple->getDM();
 
    VectorDouble vals;
    MatrixDouble diff_vals;
 
    auto assemble_matrices_and_vectors = [&]() {
      MoFEMFunctionBegin;
 
      using OpSource = FormsIntegrators<DomainEleOp>::Assembly<
          PETSC>::LinearForm<GAUSS>::OpSource<1, 1>;
 
      CHKERR AddHOOps<SPACE_DIM, SPACE_DIM, SPACE_DIM>::add(
          pipeline_mng->getOpDomainLhsPipeline(), {space});
      CHKERR AddHOOps<SPACE_DIM, SPACE_DIM, SPACE_DIM>::add(
          pipeline_mng->getOpDomainRhsPipeline(), {space});
 
      using OpMass = FormsIntegrators<DomainEleOp>::Assembly<
          SCHUR>::BiLinearForm<GAUSS>::OpMass<1, 1>;
 
      pipeline_mng->getOpDomainLhsPipeline().push_back(
          createOpSchurAssembleBegin());
      pipeline_mng->getOpDomainLhsPipeline().push_back(new OpMass(
          "FIELD1", "FIELD1", [](double, double, double) { return 1.; }));
      pipeline_mng->getOpDomainLhsPipeline().push_back(
          createOpSchurAssembleEnd({}, {}));
 
      pipeline_mng->getOpDomainRhsPipeline().push_back(
          new OpSource("FIELD1", ApproxFunctions::fUn));
 
      auto integration_rule = [](int, int, int p_data) {
        return 2 * p_data + 1;
      };
      CHKERR pipeline_mng->setDomainRhsIntegrationRule(integration_rule);
      CHKERR pipeline_mng->setDomainLhsIntegrationRule(integration_rule);
 
      MoFEMFunctionReturn(0);
    };
 
    auto solve_problem = [&] {
      MoFEMFunctionBegin;
      auto solver = pipeline_mng->createKSP();
      CHKERR KSPSetFromOptions(solver);
      CHKERR KSPSetUp(solver);
 
      auto dm = simple->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);
    };
 
    auto check_solution = [&] {
      MoFEMFunctionBegin;
 
      auto ptr_values = boost::make_shared<VectorDouble>();
      auto ptr_diff_vals = boost::make_shared<MatrixDouble>();
 
      pipeline_mng->getDomainLhsFE().reset();
      pipeline_mng->getOpDomainRhsPipeline().clear();
 
      CHKERR AddHOOps<SPACE_DIM, SPACE_DIM, SPACE_DIM>::add(
          pipeline_mng->getOpDomainRhsPipeline(), {space});
 
      pipeline_mng->getOpDomainRhsPipeline().push_back(
          new OpValsDiffVals(vals, diff_vals, true));
      pipeline_mng->getOpDomainRhsPipeline().push_back(
          new OpCalculateScalarFieldValues("FIELD1", ptr_values));
      pipeline_mng->getOpDomainRhsPipeline().push_back(
          new OpCalculateScalarFieldGradient<SPACE_DIM>("FIELD1",
                                                        ptr_diff_vals));
      pipeline_mng->getOpDomainRhsPipeline().push_back(new OpCheckValsDiffVals(
          vals, diff_vals, ptr_values, ptr_diff_vals, true));
 
      CHKERR pipeline_mng->loopFiniteElements();
 
      MoFEMFunctionReturn(0);
    };
 
    auto post_proc = [&] {
      MoFEMFunctionBegin;
 
      using OpPPMap = OpPostProcMapInMoab<SPACE_DIM, SPACE_DIM>;
 
      auto get_domain_post_proc_fe = [&](auto post_proc_mesh_ptr) {
        auto post_proc_fe =
            boost::make_shared<PostProcBrokenMeshInMoabBaseCont<DomainEle>>(
                m_field, post_proc_mesh_ptr);
 
        CHKERR AddHOOps<SPACE_DIM, SPACE_DIM, SPACE_DIM>::add(
            post_proc_fe->getOpPtrVector(), {space});
 
        auto ptr_values = boost::make_shared<VectorDouble>();
        auto ptr_diff_vals = boost::make_shared<MatrixDouble>();
 
        post_proc_fe->getOpPtrVector().push_back(
            new OpCalculateScalarFieldValues("FIELD1", ptr_values));
        post_proc_fe->getOpPtrVector().push_back(
            new OpCalculateScalarFieldGradient<SPACE_DIM>("FIELD1",
                                                          ptr_diff_vals));
 
        post_proc_fe->getOpPtrVector().push_back(
 
            new OpPPMap(
 
                post_proc_fe->getPostProcMesh(), post_proc_fe->getMapGaussPts(),
 
                {{"FIELD1", ptr_values}},
 
                {{"FIELD1_GRAD", ptr_diff_vals}},
 
                {}, {})
 
        );
        return post_proc_fe;
      };
 
      auto get_bdy_post_proc_fe = [&](auto post_proc_mesh_ptr) {
        auto bdy_post_proc_fe =
            boost::make_shared<PostProcBrokenMeshInMoabBaseCont<BoundaryEle>>(
                m_field, post_proc_mesh_ptr);
 
        auto op_loop_side = new OpLoopSide<EleOnSide>(
            m_field, simple->getDomainFEName(), SPACE_DIM, Sev::noisy,
            boost::make_shared<
                ForcesAndSourcesCore::UserDataOperator::AdjCache>());
 
        auto ptr_values = boost::make_shared<VectorDouble>();
        auto ptr_diff_vals = boost::make_shared<MatrixDouble>();
 
        // push operators to side element
        CHKERR AddHOOps<SPACE_DIM, SPACE_DIM, SPACE_DIM>::add(
            op_loop_side->getOpPtrVector(), {space});
        op_loop_side->getOpPtrVector().push_back(
            new OpCalculateScalarFieldValues("FIELD1", ptr_values));
        op_loop_side->getOpPtrVector().push_back(
            new OpCalculateScalarFieldGradient<SPACE_DIM>("FIELD1",
                                                          ptr_diff_vals));
        // push op to boundary element
        bdy_post_proc_fe->getOpPtrVector().push_back(op_loop_side);
 
        bdy_post_proc_fe->getOpPtrVector().push_back(
 
            new OpPPMap(
 
                bdy_post_proc_fe->getPostProcMesh(),
                bdy_post_proc_fe->getMapGaussPts(),
 
                {{"FIELD1", ptr_values}},
 
                {{"FIELD1_GRAD", ptr_diff_vals}},
 
                {}, {})
 
        );
 
        return bdy_post_proc_fe;
      };
 
      auto post_proc_mesh_ptr = boost::make_shared<moab::Core>();
      auto post_proc_begin =
          boost::make_shared<PostProcBrokenMeshInMoabBaseBegin>(
              m_field, post_proc_mesh_ptr);
      auto post_proc_end =
          boost::make_shared<PostProcBrokenMeshInMoabBaseEnd>(
              m_field, post_proc_mesh_ptr);
      auto domain_post_proc_fe = get_domain_post_proc_fe(post_proc_mesh_ptr);
      auto bdy_post_proc_fe = get_bdy_post_proc_fe(post_proc_mesh_ptr);
 
      CHKERR DMoFEMPreProcessFiniteElements(dm, post_proc_begin->getFEMethod());
      CHKERR DMoFEMLoopFiniteElements(dm, simple->getDomainFEName(),
                                      domain_post_proc_fe);
      CHKERR DMoFEMLoopFiniteElements(dm, simple->getBoundaryFEName(),
                                      bdy_post_proc_fe);
      CHKERR DMoFEMPostProcessFiniteElements(dm, post_proc_end->getFEMethod());
      CHKERR post_proc_end->writeFile("out_post_proc.h5m");
 
      MoFEMFunctionReturn(0);
    };
 
    CHKERR assemble_matrices_and_vectors();
    CHKERR solve_problem();
    CHKERR check_solution();
    CHKERR post_proc();
  }
  CATCH_ERRORS;
 
  CHKERR MoFEM::Core::Finalize();
}

Variable Documentation

approx_order

int approx_order = 4

static

Examples

scalar_check_approximation.cpp.

Definition at line 15 of file scalar_check_approximation.cpp.

help

char help[] = "...\n\n"

static

Definition at line 13 of file scalar_check_approximation.cpp.

SPACE_DIM

int SPACE_DIM

constexpr

Initial value:

=
    EXECUTABLE_DIMENSION

Examples

hdiv_check_approx_in_3d.cpp, and scalar_check_approximation.cpp.

Definition at line 21 of file scalar_check_approximation.cpp.