AtomTest::OpError Struct Reference

Operator to evaluate errors. More...

Collaboration diagram for AtomTest::OpError:

Public Member Functions
	OpError (boost::shared_ptr< MatrixDouble > data_ptr)
MoFEMErrorCode	doWork (int side, EntityType type, EntData &data)
	OpError (boost::shared_ptr< CommonData > &common_data_ptr)
MoFEMErrorCode	doWork (int side, EntityType type, EntData &data)

Public Attributes
boost::shared_ptr< CommonData >	commonDataPtr

Private Attributes
boost::shared_ptr< MatrixDouble >	dataPtr

Detailed Description

Operator to evaluate errors.

Examples

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

Definition at line 82 of file child_and_parent.cpp.

Constructor & Destructor Documentation

OpError() [1/2]

AtomTest::OpError::OpError ( boost::shared_ptr< MatrixDouble >  data_ptr )

inline

Definition at line 95 of file dg_projection.cpp.

      : DomainEleOp(NOSPACE, OPSPACE), dataPtr(data_ptr) {}

OpError() [2/2]

AtomTest::OpError::OpError ( boost::shared_ptr< CommonData > &  common_data_ptr )

inline

Definition at line 117 of file higher_derivatives.cpp.

      : DomainEleOp(FIELD_NAME, OPROW), commonDataPtr(common_data_ptr) {
    std::fill(doEntities.begin(), doEntities.end(), false);
    doEntities[MBVERTEX] = true;
  }

Member Function Documentation

doWork() [1/2]

MoFEMErrorCode AtomTest::OpError::doWork ( int  side, EntityType  type, EntData &  data  )

inline

Definition at line 98 of file dg_projection.cpp.

                                                                  {
    MoFEMFunctionBegin;
 
    const int nb_integration_pts = getGaussPts().size2();
    auto t_val = getFTensor1FromMat<1>(
        *(dataPtr)); // get function approximation at gauss pts
    auto t_coords = getFTensor1CoordsAtGaussPts(); // get coordinates of
                                                   // integration points
 
    for (int gg = 0; gg != nb_integration_pts; ++gg) {
 
      // Calculate errors
 
      double diff = t_val(0) - fun(t_coords(0), t_coords(1), t_coords(2));
      constexpr double eps = 1e-8;
      if (std::abs(diff) > eps) {
        MOFEM_LOG("SELF", Sev::error) << "Wrong function value " << diff;
        SETERRQ(PETSC_COMM_SELF, MOFEM_ATOM_TEST_INVALID,
                "Wrong function value");
      }
 
      // move data to next integration point
      ++t_val;
      ++t_coords;
    }
 
    MOFEM_LOG("SELF", Sev::noisy) << "All is OK";
 
    MoFEMFunctionReturn(0);
  }

doWork() [2/2]

MoFEMErrorCode AtomTest::OpError::doWork ( int  side, EntityType  type, EntData &  data  )

inline

Definition at line 122 of file higher_derivatives.cpp.

                                                                  {
    MoFEMFunctionBegin;
 
    const int nb_integration_pts = getGaussPts().size2();
    auto t_w = getFTensor0IntegrationWeight(); // ger integration weights
    auto t_val = getFTensor0FromVec(*(
        commonDataPtr->approxVals)); // get function approximation at gauss pts
    auto t_grad_val = getFTensor1FromMat<SPACE_DIM>(
        *(commonDataPtr
              ->approxGradVals)); // get gradient of approximation at gauss pts
    auto t_hessian_val = getFTensor2FromMat<SPACE_DIM, SPACE_DIM>(
        *(commonDataPtr)->approxHessianVals); // get hessian of approximation
                                              // at integration pts
 
    auto t_inv_jac = getFTensor2FromMat<SPACE_DIM, SPACE_DIM>(
        *(commonDataPtr->invJacPtr)); // get inverse of element jacobian
    auto t_coords = getFTensor1CoordsAtGaussPts(); // get coordinates of
                                                   // integration points
 
    // Indices used for tensor operations
    FTensor::Index<'i', 2> i;
    FTensor::Index<'j', 2> j;
    FTensor::Index<'k', 2> k;
    FTensor::Index<'l', 2> l;
 
    const double volume = getMeasure(); // get finite element area
 
 
    std::array<double, 3> error = {0, 0,
                                   0}; // array for storing operator errors
 
    for (int gg = 0; gg != nb_integration_pts; ++gg) {
 
      const double alpha = t_w * volume;
 
      // Calculate errors
 
      double diff = t_val - fun(t_coords(0), t_coords(1), t_coords(2));
      error[0] += alpha * pow(diff, 2);
      auto t_diff_grad = diff_fun(t_coords(0), t_coords(1), t_coords(2));
      t_diff_grad(i) -= t_grad_val(i);
 
      error[1] += alpha * t_diff_grad(i) *
                  t_diff_grad(i); // note push forward derivatives
 
      FTensor::Tensor2<double, SPACE_DIM, SPACE_DIM> t_hessian_push;
      MOFEM_LOG("SELF", Sev::noisy) << "t_hessian_val " << t_hessian_push;
 
      // hessian expected to have symmetry
      if (std::abs(t_hessian_val(0, 1) - t_hessian_val(1, 0)) >
          std::numeric_limits<float>::epsilon()) {
        MOFEM_LOG("SELF", Sev::error) << "t_hessian_val " << t_hessian_val;
        SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
                "Hessian should be symmetric");
      }
 
      auto t_diff_hessian = diff2_fun(t_coords(0), t_coords(1), t_coords(2));
      t_diff_hessian(i, j) -= t_hessian_val(i, j);
      error[2] = t_diff_hessian(i, j) * t_diff_hessian(i, j);
 
      // move data to next integration point
      ++t_w;
      ++t_val;
      ++t_grad_val;
      ++t_hessian_val;
      ++t_inv_jac;
      ++t_coords;
    }
 
    // assemble error vector
    std::array<int, 3> index = {0, 1, 2};
    CHKERR VecSetValues(commonDataPtr->L2Vec, 3, index.data(), error.data(),
                        ADD_VALUES);
 
    MoFEMFunctionReturn(0);
  }

Member Data Documentation

commonDataPtr

boost::shared_ptr< CommonData > AtomTest::OpError::commonDataPtr

Definition at line 94 of file dg_projection.cpp.

dataPtr

boost::shared_ptr<MatrixDouble> AtomTest::OpError::dataPtr

private

Definition at line 130 of file dg_projection.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/higher_derivatives.cpp