field_evaluator.cpp File Reference

#include <MoFEM.hpp>

Go to the source code of this file.

Classes
struct	MyOp< OP >
	Operator used to check consistency between local coordinates and global cooridnates for integrated points and evaluated points. More...

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

Variables
static char	help [] = "testing field evaluator\n\n"
auto	get_rule

Function Documentation

main()

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

Definition at line 77 of file field_evaluator.cpp.

                                 {
 
  MoFEM::Core::Initialize(&argc, &argv, (char *)0, help);
 
  try {
 
    // Read mesh and create moab and mofem data structures
    moab::Core mb_instance;
    moab::Interface &moab = mb_instance;
 
    MoFEM::Core core(moab, PETSC_COMM_WORLD);
    MoFEM::Interface &m_field = core;
 
    // Register DM Manager
    DMType dm_name = "DMMOFEM";
    CHKERR DMRegister_MoFEM(dm_name);
 
    // Simple interface
    Simple *simple_interface;
    CHKERR m_field.getInterface(simple_interface);
    {
 
      // get options from command line
      CHKERR simple_interface->getOptions();
      // load mesh file
      CHKERR simple_interface->loadFile();
      // add fields
      CHKERR simple_interface->addDomainField("FIELD1", H1,
                                              AINSWORTH_LEGENDRE_BASE, 3);
      // set fields order
      CHKERR simple_interface->setFieldOrder("FIELD1", 1);
      // setup problem
      CHKERR simple_interface->setUp();
 
      FieldEvaluatorInterface *field_eval_ptr;
      CHKERR m_field.getInterface(field_eval_ptr);
 
 
      auto dm = simple_interface->getDM();
      const MoFEM::Problem *prb_ptr;
      CHKERR DMMoFEMGetProblemPtr(dm, &prb_ptr);
 
      if (simple_interface->getDim() == 3) {
 
        std::array<double, 3> point = {0, 0, 0};
        const double dist = 0.1;
 
        std::array<double, 12> eval_points = {0.0,  0.0, 0.0, 0.0, 0.01, 0.0,
                                              -0.1, 0.0, 0.0, 0.1, 0.0,  0.0};
 
        using VolEle = VolumeElementForcesAndSourcesCore;
        using VolOp = VolEle::UserDataOperator;
 
        // Get pointer of FieldEvaluator data. Note finite element and method
        // set integrating points is destroyed when this pointer is releases
        auto data = field_eval_ptr->getData<VolEle>();
 
        // Set operators and integration rule
        if (auto fe_method = data->feMethodPtr.lock()) {
          fe_method->getRuleHook = get_rule;
          fe_method->getOpPtrVector().push_back(new MyOp<VolOp>(eval_points));
        } else
          SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
                  "Pointer to element does not exists");
 
        // Build tree for particular element
        CHKERR field_eval_ptr->buildTree3D(data,
                                           simple_interface->getDomainFEName());
        // Set points to set on finite elements
        data->setEvalPoints(eval_points.data(), eval_points.size() / 3);
 
        // Evaluate points on finite elements
        CHKERR field_eval_ptr->evalFEAtThePoint3D(
            &point[0], dist, prb_ptr->getName(),
            simple_interface->getDomainFEName(), data, m_field.get_comm_rank(),
            m_field.get_comm_rank(), nullptr, MF_EXIST, VERY_NOISY);
      }
 
      if (simple_interface->getDim() == 2) {
 
        std::array<double, 3> point = {0, 0, 0};
        const double dist = 0.1;
 
        std::array<double, 12> eval_points = {
          0.0,  0.0, 0.0, 
          0.0, 0.01, 0.0,
          -0.1, 0.0, 0.0, 
          0.1, 0.0,  0.0};
 
        using FaceEle = FaceElementForcesAndSourcesCore;
        using FaceOp = FaceEle::UserDataOperator;
 
        // Get pointer of FieldEvaluator data. Note finite element and method
        // set integrating points is destroyed when this pointer is releases
        auto data = field_eval_ptr->getData<FaceEle>();
 
        // Set operators and integration rule
        if (auto fe_method = data->feMethodPtr.lock()) {
          fe_method->getRuleHook = get_rule;
          fe_method->getOpPtrVector().push_back(new MyOp<FaceOp>(eval_points));
        } else
          SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
                  "Pointer to element does not exists");
 
        // Build tree for particular element
        CHKERR field_eval_ptr->buildTree2D(data,
                                           simple_interface->getDomainFEName());
        // Set points to set on finite elements
        data->setEvalPoints(eval_points.data(), eval_points.size() / 3);
 
        // Evaluate points on finite elements
        CHKERR field_eval_ptr->evalFEAtThePoint2D(
            &point[0], dist, prb_ptr->getName(),
            simple_interface->getDomainFEName(), data, m_field.get_comm_rank(),
            m_field.get_comm_rank(), nullptr, MF_EXIST, VERY_NOISY);
      }
 
    }
  }
  CATCH_ERRORS;
 
  MoFEM::Core::Finalize();
 
  return 0;
}

Variable Documentation

get_rule

auto get_rule

Initial value:

= [](int order_row, int order_col, int order_data) {
  return -1;
}

Examples

field_evaluator.cpp, and lorentz_force.cpp.

Definition at line 73 of file field_evaluator.cpp.

                                                                 {
  return -1;
};

help

char help[] = "testing field evaluator\n\n"

static

Definition at line 14 of file field_evaluator.cpp.