ApproxFunctions Struct Reference

Static Public Member Functions
static FTensor::Tensor1< double, BASE_DIM >	fUn (const double x, const double y, double z)
static FTensor::Tensor2< double, BASE_DIM, SPACE_DIM >	diffFun (const double x, const double y)
static FTensor::Tensor3< double, BASE_DIM, SPACE_DIM, SPACE_DIM >	diff2Fun (const double x, const double y)
static FTensor::Tensor1< double, BASE_DIM >	fUn (const double x, const double y, double z)
static FTensor::Tensor2< double, BASE_DIM, SPACE_DIM >	diffFun (const double x, const double y, const double z)

Detailed Description

Examples

mofem/atom_tests/hcurl_check_approx_in_2d.cpp, mofem/atom_tests/hdiv_check_approx_in_3d.cpp, and mofem/atom_tests/scalar_check_approximation.cpp.

Definition at line 44 of file hcurl_check_approx_in_2d.cpp.

Member Function Documentation

diff2Fun()

static FTensor::Tensor3< double, BASE_DIM, SPACE_DIM, SPACE_DIM > ApproxFunctions::diff2Fun ( const double  x, const double  y  )

inlinestatic

Examples

mofem/atom_tests/hcurl_check_approx_in_2d.cpp.

Definition at line 92 of file hcurl_check_approx_in_2d.cpp.

                                           {
    return FTensor::Tensor3<double, BASE_DIM, SPACE_DIM, SPACE_DIM>(
        // x,xx 0/000
 
        30 * 4 * a6 * pow(x, 3) * pow(y, 0) +
            20 * 3 * a5 * pow(x, 2) * pow(y, 1) +
            12 * 2 * a4 * pow(x, 1) * pow(y, 2) +
            6 * 1 * a3 * pow(x, 0) * pow(y, 3),
 
        // x,xy 1/001
 
        20 * 1 * a5 * pow(x, 3) * pow(y, 0) +
            12 * 2 * a4 * pow(x, 2) * pow(y, 2) +
            6 * 3 * a3 * pow(x, 1) * pow(y, 2) +
            2 * 4 * a2 * pow(x, 0) * pow(y, 3),
 
        // x,yx 2/010
 
        5 * 4 * a5 * pow(x, 3) * pow(y, 0) +
            8 * 3 * a4 * pow(x, 2) * pow(y, 1) +
            9 * 2 * a3 * pow(x, 1) * pow(y, 2) +
            8 * 1 * a2 * pow(x, 0) * pow(y, 3),
 
        // x,yy 3/011
 
        8 * 1 * a4 * pow(x, 3) * pow(y, 0) +
            9 * 2 * a3 * pow(x, 2) * pow(y, 1) +
            8 * 3 * a2 * pow(x, 1) * pow(y, 2) +
            5 * 4 * a1 * pow(x, 0) * pow(y, 3),
 
        // y,xx 4/100
 
        5 * 4 * a5 * pow(x, 3) * pow(y, 0) +
            8 * 3 * a4 * pow(x, 2) * pow(y, 1) +
            9 * 2 * a3 * pow(x, 1) * pow(y, 2) +
            8 * 1 * a2 * pow(x, 0) * pow(y, 3),
 
        // y,xy 5/101
 
        8 * 1 * a4 * pow(x, 3) * pow(y, 0) +
            9 * 2 * a3 * pow(x, 2) * pow(y, 1) +
            8 * 3 * a2 * pow(x, 1) * pow(y, 2) +
            5 * 4 * a1 * pow(x, 0) * pow(y, 3),
 
        // y,yx 6/110
 
        2 * 4 * a4 * pow(x, 3) * pow(y, 0) +
            6 * 3 * a3 * pow(x, 2) * pow(y, 1) +
            12 * 2 * a2 * pow(x, 1) * pow(y, 2) +
            20 * 1 * a1 * pow(x, 0) * pow(y, 3),
 
        // y,yy 7/111
 
        6 * 1 * a3 * pow(x, 3) * pow(y, 0) +
            12 * 2 * a2 * pow(x, 2) * pow(y, 1) +
            20 * 3 * a1 * pow(x, 1) * pow(y, 2) +
            30 * 4 * a0 * pow(x, 0) * pow(y, 3),
 
        // z,xx 8/200
        0.,
        // z,xy 9/201
        0.,
        // z,yx 10/210
        0.,
        // z,yy 11/211
        0.);
  }

diffFun() [1/2]

static FTensor::Tensor2< double, BASE_DIM, SPACE_DIM > ApproxFunctions::diffFun ( const double  x, const double  y  )

inlinestatic

Examples

mofem/atom_tests/hcurl_check_approx_in_2d.cpp, and mofem/atom_tests/hdiv_check_approx_in_3d.cpp.

Definition at line 68 of file hcurl_check_approx_in_2d.cpp.

                                                                               {
    return FTensor::Tensor2<double, BASE_DIM, SPACE_DIM>(
        // x,x
        30 * a6 * pow(x, 4) * pow(y, 0) + 20 * a5 * pow(x, 3) * pow(y, 1) +
            12 * a4 * pow(x, 2) * pow(y, 2) + 6 * a3 * pow(x, 1) * pow(y, 3) +
            2 * a2 * pow(x, 0) * pow(y, 4),
        // x,y
        5 * a5 * pow(x, 4) * pow(y, 0) + 8 * a4 * pow(x, 3) * pow(y, 1) +
            9 * a3 * pow(x, 2) * pow(y, 2) + 8 * a2 * pow(x, 1) * pow(y, 3) +
            5 * a1 * pow(x, 0) * pow(y, 4),
        // y,x
        5 * a5 * pow(x, 4) * pow(y, 0) + 8 * a4 * pow(x, 3) * pow(y, 1) +
            9 * a3 * pow(x, 2) * pow(y, 2) + 8 * a2 * pow(x, 1) * pow(y, 3) +
            5 * a1 * pow(x, 0) * pow(y, 4),
        // y,y
        2 * a4 * pow(x, 4) * pow(y, 0) + 6 * a3 * pow(x, 3) * pow(y, 1) +
            12 * a2 * pow(x, 2) * pow(y, 2) + 20 * a1 * pow(x, 1) * pow(y, 3) +
            30 * a0 * pow(x, 0) * pow(y, 4),
        // z
        0., 0.);
  }

diffFun() [2/2]

static FTensor::Tensor2< double, BASE_DIM, SPACE_DIM > ApproxFunctions::diffFun ( const double  x, const double  y, const double  z  )

inlinestatic

Definition at line 56 of file hdiv_check_approx_in_3d.cpp.

                                                          {
    return FTensor::Tensor2<double, BASE_DIM, SPACE_DIM>(
        // x,x
        1. + 3 * x * x,
        // x,y
        2. * y,
        // x, z
        0.,
        // y,x
        z,
        // y,y
        1. + 3 * y * y,
        // y,z
        x,
        // z
        2 * x, 0., 1. + 3 * z * z);
  }

fUn() [1/2]

static FTensor::Tensor1< double, BASE_DIM > ApproxFunctions::fUn ( const double  x, const double  y, double  z  )

inlinestatic

Examples

mofem/atom_tests/hcurl_check_approx_in_2d.cpp, and mofem/atom_tests/hdiv_check_approx_in_3d.cpp.

Definition at line 46 of file hcurl_check_approx_in_2d.cpp.

                                                          {
    return FTensor::Tensor1<double, BASE_DIM>(
        // x
        6 * a6 * std::pow(x, 5) * std::pow(y, 0) +
            5 * a5 * std::pow(x, 4) * std::pow(y, 1) +
            4 * a4 * std::pow(x, 3) * std::pow(y, 2) +
            3 * a3 * std::pow(x, 2) * std::pow(y, 3) +
            2 * a2 * std::pow(x, 1) * std::pow(y, 4) +
            1 * a1 * std::pow(x, 0) * std::pow(y, 5),
        // y
        1 * a5 * std::pow(x, 5) * std::pow(y, 0) +
            2 * a4 * std::pow(x, 4) * std::pow(y, 1) +
            3 * a3 * std::pow(x, 3) * std::pow(y, 2) +
            4 * a2 * std::pow(x, 2) * std::pow(y, 3) +
            5 * a1 * std::pow(x, 1) * std::pow(y, 4) +
            6 * a0 * std::pow(x, 0) * std::pow(y, 5),
 
        // z
        0.);
  }

fUn() [2/2]

static FTensor::Tensor1< double, BASE_DIM > ApproxFunctions::fUn ( const double  x, const double  y, double  z  )

inlinestatic

Definition at line 44 of file hdiv_check_approx_in_3d.cpp.

                                                          {
    return FTensor::Tensor1<double, BASE_DIM>(
        // x
        x + y*y + x*x*x,
        // y
        y + z*x + y*y*y,
        // z
        z + x*x + z*z*z);
  }

---

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

• atom_tests/hcurl_check_approx_in_2d.cpp
• atom_tests/hdiv_check_approx_in_3d.cpp