FESideTest< order, family, elem_type > Class Template Reference

Inheritance diagram for FESideTest< order, family, elem_type >:

Public Member Functions
void	setUp ()
void	tearDown ()
template<typename Functor >
void	testSideLoop (Functor f)
void	testU ()
void	testGradU ()
void	testGradUComp ()
void	testHessU ()
void	testHessUComp ()

Static Protected Member Functions
static RealGradient	true_gradient (Point p)
static RealTensor	true_hessian (Point p)

Protected Attributes
std::string	libmesh_suite_name
std::string	_case_name
	Name of the case, can be used in the test to switch cases.
unsigned int	_dim
unsigned int	_nx
unsigned int	_ny
unsigned int	_nz
Elem *	_elem
std::vector< dof_id_type >	_dof_indices
System *	_sys
std::unique_ptr< Mesh >	_mesh
std::unique_ptr< EquationSystems >	_es
std::unique_ptr< FEBase >	_fe
std::unique_ptr< QGauss >	_qrule
Real	_value_tol
Real	_grad_tol
Real	_hess_tol

Private Attributes
std::unique_ptr< FEBase >	_fe_side
std::unique_ptr< QGauss >	_qrule_side

Detailed Description

template<Order order, FEFamily family, ElemType elem_type>
class FESideTest< order, family, elem_type >

Definition at line 41 of file fe_side_test.C.

Member Function Documentation

setUp()

template<Order order, FEFamily family, ElemType elem_type>

void FESideTest< order, family, elem_type >::setUp ( )

inline

Definition at line 48 of file fe_side_test.C.

  {
    FETestBase<order,family,elem_type,N_x>::setUp();
 
    // If we're a 2D mesh on a 3D libMesh build we should be able to
    // handle inverted elements just fine.  Let's test that.
    BoundaryInfo & bdy_info = this->_mesh->get_boundary_info();
    for (auto e : this->_mesh->element_ptr_range())
      if (!(e->id() % 3) && e->dim() < LIBMESH_DIM)
        e->flip(&bdy_info);
 
    FEType fe_type = this->_sys->variable_type(0);
    _fe_side = FEBase::build(this->_dim, fe_type);
 
    _qrule_side = std::make_unique<QGauss>(this->_dim-1, fe_type.default_quadrature_order());
    _fe_side->attach_quadrature_rule(this->_qrule_side.get());
 
    _fe_side->get_xyz();
    _fe_side->get_normals();
    _fe_side->get_phi();
    _fe_side->get_dphi();
    _fe_side->get_dphidx();
#if LIBMESH_DIM > 1
    _fe_side->get_dphidy();
#endif
#if LIBMESH_DIM > 2
    _fe_side->get_dphidz();
#endif
 
#if LIBMESH_ENABLE_SECOND_DERIVATIVES
 
    // Clough-Tocher elements still don't work multithreaded
    if (family == CLOUGH && libMesh::n_threads() > 1)
      return;
 
    // Szabab elements don't have second derivatives yet
    if (family == SZABAB)
      return;
 
    _fe_side->get_d2phi();
    _fe_side->get_d2phidx2();
#if LIBMESH_DIM > 1
    _fe_side->get_d2phidxdy();
    _fe_side->get_d2phidy2();
#endif
#if LIBMESH_DIM > 2
    _fe_side->get_d2phidxdz();
    _fe_side->get_d2phidydz();
    _fe_side->get_d2phidz2();
#endif
 
#endif
  }

References FETestBase< order, family, elem_type, N_x >::_dim, FESideTest< order, family, elem_type >::_fe_side, FETestBase< order, family, elem_type, N_x >::_mesh, FESideTest< order, family, elem_type >::_qrule_side, FETestBase< order, family, elem_type, N_x >::_sys, libMesh::n_threads(), and FETestBase< order, family, elem_type, build_nx, CaseName >::setUp().

tearDown()

template<Order order, FEFamily family, ElemType elem_type>

void FESideTest< order, family, elem_type >::tearDown ( )

inline

Definition at line 102 of file fe_side_test.C.

  {
    FETestBase<order,family,elem_type,N_x>::tearDown();
  }

References FETestBase< order, family, elem_type, build_nx, CaseName >::tearDown().

testGradU()

template<Order order, FEFamily family, ElemType elem_type>

void FESideTest< order, family, elem_type >::testGradU ( )

inline

Definition at line 180 of file fe_side_test.C.

  {
    LOG_UNIT_TEST;
 
    auto f = [this]() {
      Parameters dummy;
 
      auto dphi = this->_fe_side->get_dphi();
      CPPUNIT_ASSERT(dphi.size() > 0);
      CPPUNIT_ASSERT_EQUAL(dphi.size(), this->_dof_indices.size());
 
      std::size_t n_qp = dphi[0].size();
      CPPUNIT_ASSERT(n_qp > 0);
 
      auto xyz = this->_fe_side->get_xyz();
      CPPUNIT_ASSERT_EQUAL(n_qp, xyz.size());
 
      auto normals = this->_fe_side->get_normals();
      CPPUNIT_ASSERT_EQUAL(n_qp, normals.size());
 
      const Point c =  this->_elem->vertex_average();
 
      for (auto qp : index_range(dphi[0]))
        {
          Gradient grad_u = 0;
          for (auto d : index_range(dphi))
            grad_u += dphi[d][qp] * (*this->_sys->current_local_solution)(this->_dof_indices[d]);
 
          const Point p = xyz[qp];
          const Point n = normals[qp];
 
          // All our normals should be unit normals.
          LIBMESH_ASSERT_FP_EQUAL(Real(n.norm()),
                                  Real(1),
                                  this->_grad_tol);
 
          // All our normals should be outward-facing.  For the simple
          // meshes here this is sufficient to make sure they're not
          // flipped:
          CPPUNIT_ASSERT_GREATER(Real(0), (p-c)*n);
 
          // We can only trust the tangential component of gradient to
          // match!  The gradient in the normal direction should be 0
          // for a shape-preserving master->physical element
          // transformation, and could be just about anything for a
          // skew transformation (as occurs when we build meshes with
          // triangles, tets, prisms, pyramids...)
 
          const Gradient tangential_grad_u = grad_u - ((grad_u * n) * n);
 
          if (family == RATIONAL_BERNSTEIN && order > 1)
            {
              // TODO: Yeah we'll test the ugly expressions later.
              return;
            }
 
          RealGradient true_grad = this->true_gradient(p);
          if (order == 0)
            true_grad.zero();
 
          const Gradient true_tangential_grad = true_grad - ((true_grad * n) * n);
 
          LIBMESH_ASSERT_NUMBERS_EQUAL(tangential_grad_u(0),
                                      true_tangential_grad(0),
                                      this->_grad_tol);
          if (this->_dim > 1)
            LIBMESH_ASSERT_NUMBERS_EQUAL(tangential_grad_u(1),
                                        true_tangential_grad(1),
                                        this->_grad_tol);
          if (this->_dim > 2)
            LIBMESH_ASSERT_NUMBERS_EQUAL(tangential_grad_u(2),
                                        true_tangential_grad(2),
                                        this->_grad_tol);
        }
    };
 
    testSideLoop(f);
  }

References FETestBase< order, family, elem_type, N_x >::_dim, FETestBase< order, family, elem_type, N_x >::_dof_indices, FETestBase< order, family, elem_type, N_x >::_elem, FETestBase< order, family, elem_type, N_x >::_grad_tol, FETestBase< order, family, elem_type, N_x >::_sys, FESideTest< order, family, elem_type >::testSideLoop(), and FETestBase< order, family, elem_type, N_x >::true_gradient().

testGradUComp()

template<Order order, FEFamily family, ElemType elem_type>

void FESideTest< order, family, elem_type >::testGradUComp ( )

inline

Definition at line 259 of file fe_side_test.C.

  {
    LOG_UNIT_TEST;
 
    auto f = [this]() {
      Parameters dummy;
 
      auto dphidx = this->_fe_side->get_dphidx();
      CPPUNIT_ASSERT(dphidx.size() > 0);
      CPPUNIT_ASSERT_EQUAL(dphidx.size(), this->_dof_indices.size());
#if LIBMESH_DIM > 1
      auto dphidy = this->_fe_side->get_dphidy();
      CPPUNIT_ASSERT_EQUAL(dphidy.size(), this->_dof_indices.size());
#endif
#if LIBMESH_DIM > 2
      auto dphidz = this->_fe_side->get_dphidz();
      CPPUNIT_ASSERT_EQUAL(dphidz.size(), this->_dof_indices.size());
#endif
 
      std::size_t n_qp = dphidx[0].size();
      CPPUNIT_ASSERT(n_qp > 0);
 
      auto xyz = this->_fe_side->get_xyz();
      CPPUNIT_ASSERT_EQUAL(n_qp, xyz.size());
 
      auto normals = this->_fe_side->get_normals();
      CPPUNIT_ASSERT_EQUAL(n_qp, normals.size());
 
      for (auto qp : index_range(dphidx[0]))
        {
          Number grad_u_x = 0, grad_u_y = 0, grad_u_z = 0;
          for (auto d : index_range(dphidx))
            {
              grad_u_x += dphidx[d][qp] * (*this->_sys->current_local_solution)(this->_dof_indices[d]);
#if LIBMESH_DIM > 1
              grad_u_y += dphidy[d][qp] * (*this->_sys->current_local_solution)(this->_dof_indices[d]);
#endif
#if LIBMESH_DIM > 2
              grad_u_z += dphidz[d][qp] * (*this->_sys->current_local_solution)(this->_dof_indices[d]);
#endif
            }
 
          const Point p = xyz[qp];
 
          // We can only trust the tangential component of gradient to
          // match!  The gradient in the normal direction should be 0
          // for a shape-preserving master->physical element
          // transformation, and could be just about anything for a
          // skew transformation (as occurs when we build meshes with
          // triangles, tets, prisms, pyramids...)
          Point n = normals[qp];
 
          const Gradient grad_u {grad_u_x, grad_u_y, grad_u_z};
          const Gradient tangential_grad_u = grad_u - ((grad_u * n) * n);
 
          if (family == RATIONAL_BERNSTEIN && order > 1)
            {
              // TODO: Yeah we'll test the ugly expressions later.
              return;
            }
 
          RealGradient true_grad = this->true_gradient(p);
          if (order == 0)
            true_grad.zero();
 
          const Gradient true_tangential_grad = true_grad - ((true_grad * n) * n);
 
          LIBMESH_ASSERT_NUMBERS_EQUAL(tangential_grad_u(0),
                                      true_tangential_grad(0),
                                      this->_grad_tol);
          if (this->_dim > 1)
            LIBMESH_ASSERT_NUMBERS_EQUAL(tangential_grad_u(1),
                                    true_tangential_grad(1),
                                    this->_grad_tol);
          if (this->_dim > 2)
            LIBMESH_ASSERT_NUMBERS_EQUAL(tangential_grad_u(2),
                                        true_tangential_grad(2),
                                        this->_grad_tol);
        }
    };
 
    testSideLoop(f);
  }

References FETestBase< order, family, elem_type, N_x >::_dim, FETestBase< order, family, elem_type, N_x >::_dof_indices, FETestBase< order, family, elem_type, N_x >::_grad_tol, FETestBase< order, family, elem_type, N_x >::_sys, FESideTest< order, family, elem_type >::testSideLoop(), and FETestBase< order, family, elem_type, N_x >::true_gradient().

testHessU()

template<Order order, FEFamily family, ElemType elem_type>

void FESideTest< order, family, elem_type >::testHessU ( )

inline

Definition at line 344 of file fe_side_test.C.

  {
    LOG_UNIT_TEST;
 
#ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
    // Szabab elements don't have second derivatives yet
    if (family == SZABAB)
      return;
 
    auto f = [this]() {
      Parameters dummy;
 
      auto d2phi = this->_fe_side->get_d2phi();
      CPPUNIT_ASSERT(d2phi.size() > 0);
      CPPUNIT_ASSERT_EQUAL(d2phi.size(), this->_dof_indices.size());
 
      std::size_t n_qp = d2phi[0].size();
      CPPUNIT_ASSERT(n_qp > 0);
 
      auto xyz = this->_fe_side->get_xyz();
      CPPUNIT_ASSERT_EQUAL(n_qp, xyz.size());
 
      auto normals = this->_fe_side->get_normals();
      CPPUNIT_ASSERT_EQUAL(n_qp, normals.size());
 
      for (auto qp : index_range(d2phi[0]))
        {
          Tensor hess_u;
          for (auto d : index_range(d2phi))
            hess_u += d2phi[d][qp] * (*this->_sys->current_local_solution)(this->_dof_indices[d]);
 
          // We can only trust the tangential-tangential components of
          // hessians, t1'*H*t2 for tangential vectors t1 and t2, to
          // match!  The hessian components in the normal direction
          // should be 0 for a shape-preserving master->physical
          // element transformation, but could be just about anything
          // for a skew transformation (as occurs when we build meshes
          // with triangles, tets, prisms, pyramids...)
          Point n = normals[qp];
          hess_u = tangential_hessian(hess_u, n);
 
          if (family == RATIONAL_BERNSTEIN && order > 1)
            {
              // TODO: Yeah we'll test the ugly expressions later.
              return;
            }
 
          const Point p = xyz[qp];
          RealTensor true_hess = this->true_hessian(p);
 
          // Subtract off values only relevant in normal directions
          RealTensor tangential_hess = tangential_hessian(true_hess, n);
 
          LIBMESH_ASSERT_NUMBERS_EQUAL(tangential_hess(0,0),
                                      hess_u(0,0), this->_hess_tol);
          if (this->_dim > 1)
            {
              LIBMESH_ASSERT_NUMBERS_EQUAL
                (hess_u(0,1), hess_u(1,0), this->_hess_tol);
              LIBMESH_ASSERT_NUMBERS_EQUAL
                (tangential_hess(0,1), hess_u(0,1), this->_hess_tol);
              LIBMESH_ASSERT_NUMBERS_EQUAL
                (tangential_hess(1,1), hess_u(1,1), this->_hess_tol);
            }
          if (this->_dim > 2)
            {
              LIBMESH_ASSERT_NUMBERS_EQUAL
                (hess_u(0,2), hess_u(2,0), this->_hess_tol);
              LIBMESH_ASSERT_NUMBERS_EQUAL
                (hess_u(1,2), hess_u(2,1), this->_hess_tol);
              LIBMESH_ASSERT_NUMBERS_EQUAL
                (tangential_hess(0,2), hess_u(0,2), this->_hess_tol);
              LIBMESH_ASSERT_NUMBERS_EQUAL
                (tangential_hess(1,2), hess_u(1,2), this->_hess_tol);
              LIBMESH_ASSERT_NUMBERS_EQUAL
                (tangential_hess(2,2), hess_u(2,2), this->_hess_tol);
            }
        }
    };
 
    testSideLoop(f);
#endif // LIBMESH_ENABLE_SECOND_DERIVATIVES
  }

References FETestBase< order, family, elem_type, N_x >::_dim, FETestBase< order, family, elem_type, N_x >::_dof_indices, FETestBase< order, family, elem_type, N_x >::_hess_tol, FETestBase< order, family, elem_type, N_x >::_sys, FESideTest< order, family, elem_type >::testSideLoop(), and FETestBase< order, family, elem_type, N_x >::true_hessian().

testHessUComp()

template<Order order, FEFamily family, ElemType elem_type>

void FESideTest< order, family, elem_type >::testHessUComp ( )

inline

Definition at line 428 of file fe_side_test.C.

  {
    LOG_UNIT_TEST;
 
#ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
    // Szabab elements don't have second derivatives yet
    if (family == SZABAB)
      return;
 
    auto f = [this]() {
      Parameters dummy;
 
      auto d2phidx2 = this->_fe_side->get_d2phidx2();
      CPPUNIT_ASSERT(d2phidx2.size() > 0);
      CPPUNIT_ASSERT_EQUAL(d2phidx2.size(), this->_dof_indices.size());
#if LIBMESH_DIM > 1
      auto d2phidxdy = this->_fe_side->get_d2phidxdy();
      CPPUNIT_ASSERT_EQUAL(d2phidxdy.size(), this->_dof_indices.size());
      auto d2phidy2 = this->_fe_side->get_d2phidy2();
      CPPUNIT_ASSERT_EQUAL(d2phidy2.size(), this->_dof_indices.size());
#endif
#if LIBMESH_DIM > 2
      auto d2phidxdz = this->_fe_side->get_d2phidxdz();
      CPPUNIT_ASSERT_EQUAL(d2phidxdz.size(), this->_dof_indices.size());
      auto d2phidydz = this->_fe_side->get_d2phidydz();
      CPPUNIT_ASSERT_EQUAL(d2phidydz.size(), this->_dof_indices.size());
      auto d2phidz2 = this->_fe_side->get_d2phidz2();
      CPPUNIT_ASSERT_EQUAL(d2phidz2.size(), this->_dof_indices.size());
#endif
 
      std::size_t n_qp = d2phidx2[0].size();
      CPPUNIT_ASSERT(n_qp > 0);
 
      auto xyz = this->_fe_side->get_xyz();
      CPPUNIT_ASSERT_EQUAL(n_qp, xyz.size());
 
      auto normals = this->_fe_side->get_normals();
      CPPUNIT_ASSERT_EQUAL(n_qp, normals.size());
 
      for (auto qp : index_range(d2phidx2[0]))
        {
          Tensor hess_u;
          for (auto d : index_range(d2phidx2))
            {
              hess_u(0,0) += d2phidx2[d][qp] * (*this->_sys->current_local_solution)(this->_dof_indices[d]);
#if LIBMESH_DIM > 1
              hess_u(0,1) += d2phidxdy[d][qp] * (*this->_sys->current_local_solution)(this->_dof_indices[d]);
              hess_u(1,1) += d2phidy2[d][qp] * (*this->_sys->current_local_solution)(this->_dof_indices[d]);
#endif
#if LIBMESH_DIM > 2
              hess_u(0,2) += d2phidxdz[d][qp] * (*this->_sys->current_local_solution)(this->_dof_indices[d]);
              hess_u(1,2) += d2phidydz[d][qp] * (*this->_sys->current_local_solution)(this->_dof_indices[d]);
              hess_u(2,2) += d2phidz2[d][qp] * (*this->_sys->current_local_solution)(this->_dof_indices[d]);
#endif
            }
 
#if LIBMESH_DIM > 1
          hess_u(1,0) = hess_u(0,1);
#endif
#if LIBMESH_DIM > 2
          hess_u(2,0) = hess_u(0,2);
          hess_u(2,1) = hess_u(1,2);
#endif
 
          // We can only trust the tangential-tangential components of
          // hessians, t1'*H*t2 for tangential vectors t1 and t2, to
          // match!  The hessian components in the normal direction
          // should be 0 for a shape-preserving master->physical
          // element transformation, but could be just about anything
          // for a skew transformation (as occurs when we build meshes
          // with triangles, tets, prisms, pyramids...)
          Point n = normals[qp];
          hess_u = tangential_hessian(hess_u, n);
 
          if (family == RATIONAL_BERNSTEIN && order > 1)
            return;
 
          const Point p = xyz[qp];
          RealTensor true_hess = this->true_hessian(p);
 
          // Subtract off values only relevant in normal directions
          RealTensor tangential_hess = tangential_hessian(true_hess, n);
 
          LIBMESH_ASSERT_NUMBERS_EQUAL
            (tangential_hess(0,0), hess_u(0,0), this->_hess_tol);
          if (this->_dim > 1)
            {
              LIBMESH_ASSERT_NUMBERS_EQUAL
                (tangential_hess(0,1), hess_u(0,1), this->_hess_tol);
              LIBMESH_ASSERT_NUMBERS_EQUAL
                (tangential_hess(1,1), hess_u(1,1), this->_hess_tol);
            }
          if (this->_dim > 2)
            {
              LIBMESH_ASSERT_NUMBERS_EQUAL
                (tangential_hess(0,2), hess_u(0,2), this->_hess_tol);
              LIBMESH_ASSERT_NUMBERS_EQUAL
                (tangential_hess(1,2), hess_u(1,2), this->_hess_tol);
              LIBMESH_ASSERT_NUMBERS_EQUAL
                (tangential_hess(2,2), hess_u(2,2), this->_hess_tol);
            }
        }
    };
 
    testSideLoop(f);
#endif // LIBMESH_ENABLE_SECOND_DERIVATIVES
  }

References FETestBase< order, family, elem_type, N_x >::_dim, FETestBase< order, family, elem_type, N_x >::_dof_indices, FETestBase< order, family, elem_type, N_x >::_hess_tol, FETestBase< order, family, elem_type, N_x >::_sys, FESideTest< order, family, elem_type >::testSideLoop(), and FETestBase< order, family, elem_type, N_x >::true_hessian().

testSideLoop()

template<Order order, FEFamily family, ElemType elem_type>

template<typename Functor >

void FESideTest< order, family, elem_type >::testSideLoop ( Functor  f )

inline

Definition at line 108 of file fe_side_test.C.

  {
    // Clough-Tocher elements still don't work multithreaded
    if (family == CLOUGH && libMesh::n_threads() > 1)
      return;
 
    for (auto e : this->_mesh->active_local_element_ptr_range())
      {
        this->_elem = e;
 
        this->_sys->get_dof_map().dof_indices(this->_elem, this->_dof_indices);
 
        for (unsigned int s=0; s != this->_elem->n_sides(); ++s)
          {
            _fe_side->reinit(this->_elem, s);
 
            f();
          }
      }
  }

References FETestBase< order, family, elem_type, N_x >::_dof_indices, FETestBase< order, family, elem_type, N_x >::_elem, FESideTest< order, family, elem_type >::_fe_side, FETestBase< order, family, elem_type, N_x >::_mesh, FETestBase< order, family, elem_type, N_x >::_sys, and libMesh::n_threads().

Referenced by FESideTest< order, family, elem_type >::testGradU(), FESideTest< order, family, elem_type >::testGradUComp(), FESideTest< order, family, elem_type >::testHessU(), FESideTest< order, family, elem_type >::testHessUComp(), and FESideTest< order, family, elem_type >::testU().

testU()

template<Order order, FEFamily family, ElemType elem_type>

void FESideTest< order, family, elem_type >::testU ( )

inline

Definition at line 129 of file fe_side_test.C.

  {
    LOG_UNIT_TEST;
 
    auto f = [this]() {
      Parameters dummy;
 
      auto phi = this->_fe_side->get_phi();
      CPPUNIT_ASSERT(phi.size());
      CPPUNIT_ASSERT_EQUAL(phi.size(), this->_dof_indices.size());
 
      std::size_t n_qp = phi[0].size();
      CPPUNIT_ASSERT(n_qp > 0);
 
      auto xyz = this->_fe_side->get_xyz();
      CPPUNIT_ASSERT_EQUAL(n_qp, xyz.size());
 
      for (auto qp : index_range(phi[0]))
        {
          Number u = 0;
          for (auto d : index_range(phi))
            u += phi[d][qp] * (*this->_sys->current_local_solution)(this->_dof_indices[d]);
 
          const Point p = xyz[qp];
          Real x = p(0),
               y = LIBMESH_DIM > 1 ? p(1) : 0,
               z = LIBMESH_DIM > 2 ? p(2) : 0;
 
          if (family == RATIONAL_BERNSTEIN && order > 1)
            LIBMESH_ASSERT_NUMBERS_EQUAL
              (rational_test(p, dummy, "", ""), u, this->_value_tol);
          else if (order > 3)
            LIBMESH_ASSERT_NUMBERS_EQUAL
              (fe_quartic_test(p, dummy, "", ""), u, this->_value_tol);
          else if (order > 2)
            LIBMESH_ASSERT_NUMBERS_EQUAL
              (fe_cubic_test(p, dummy, "", ""), u, this->_value_tol);
          else if (order > 1)
            LIBMESH_ASSERT_NUMBERS_EQUAL
              (x*x + 0.5*y*y + 0.25*z*z + 0.125*x*y +
                            0.0625*x*z + 0.03125*y*z,
               u, this->_value_tol);
          else
            LIBMESH_ASSERT_NUMBERS_EQUAL (x + 0.25*y + 0.0625*z, u,
                                         this->_value_tol);
        }
    };
 
    testSideLoop(f);
  }

References FETestBase< order, family, elem_type, N_x >::_dof_indices, FETestBase< order, family, elem_type, N_x >::_sys, FETestBase< order, family, elem_type, N_x >::_value_tol, fe_cubic_test(), fe_quartic_test(), rational_test(), and FESideTest< order, family, elem_type >::testSideLoop().

true_gradient()

static RealGradient FETestBase< order, family, elem_type, build_nx, Default >::true_gradient ( Point  p )

inlinestaticprotectedinherited

Definition at line 289 of file fe_test.h.

  {
    Parameters dummy;
 
    Gradient true_grad;
    RealGradient returnval;
 
    if (family == RATIONAL_BERNSTEIN && order > 1)
      true_grad = rational_test_grad(p, dummy, "", "");
    else if (order > 3)
      true_grad = fe_quartic_test_grad(p, dummy, "", "");
    else if (FE_CAN_TEST_CUBIC)
      true_grad = fe_cubic_test_grad(p, dummy, "", "");
    else if (order > 1)
      {
        const Real & x = p(0);
        const Real & y = (LIBMESH_DIM > 1) ? p(1) : 0;
        const Real & z = (LIBMESH_DIM > 2) ? p(2) : 0;
 
        true_grad = Gradient(2*x+0.125*y+0.0625*z,
                             y+0.125*x+0.03125*z,
                             0.5*z+0.0625*x+0.03125*y);
      }
    else
      true_grad = Gradient(1.0, 0.25, 0.0625);
 
    for (unsigned int d=0; d != LIBMESH_DIM; ++d)
      {
        CPPUNIT_ASSERT(true_grad(d) ==
                       Number(libmesh_real(true_grad(d))));
 
        returnval(d) = libmesh_real(true_grad(d));
      }
 
    return returnval;
  }

true_hessian()

static RealTensor FETestBase< order, family, elem_type, build_nx, Default >::true_hessian ( Point  p )

inlinestaticprotectedinherited

Definition at line 327 of file fe_test.h.

  {
    const Real & x = p(0);
    const Real & y = LIBMESH_DIM > 1 ? p(1) : 0;
    const Real & z = LIBMESH_DIM > 2 ? p(2) : 0;
 
    if (order > 3)
      return RealTensor
        { 12*x*x-12*x+2+2*z*(1-y)-2*(1-y)*(1-z), -2*x*z-(1-2*x)*(1-z)-(1-2*y)*z, 2*x*(1-y)-(1-2*x)*(1-y)-y*(1-y),
                 -2*x*z-(1-2*x)*(1-z)-(1-2*y)*z,                     -2*(1-x)*z,      -x*x+x*(1-x)+(1-x)*(1-2*y),
                2*x*(1-y)-(1-2*x)*(1-y)-y*(1-y),     -x*x+x*(1-x)+(1-x)*(1-2*y),                   12*z*z-12*z+2 };
    else if (FE_CAN_TEST_CUBIC)
      return RealTensor
        { 6*x-4+2*(1-y), -2*x+z-1,     y-1,
               -2*x+z-1,     -2*z, x+1-2*y,
                    y-1,  x+1-2*y, 6*z-4 };
    else if (order > 1)
      return RealTensor
        { 2, 0.125, 0.0625,
          0.125, 1, 0.03125,
          0.0625, 0.03125, 0.5 };
 
    return RealTensor
      { 0, 0, 0,
        0, 0, 0,
        0, 0, 0 };
  }

Member Data Documentation

_case_name

std::string FETestBase< order, family, elem_type, build_nx, Default >::_case_name

protectedinherited

Name of the case, can be used in the test to switch cases.

Definition at line 275 of file fe_test.h.

_dim

unsigned int FETestBase< order, family, elem_type, build_nx, Default >::_dim

protectedinherited

Definition at line 277 of file fe_test.h.

_dof_indices

std::vector<dof_id_type> FETestBase< order, family, elem_type, build_nx, Default >::_dof_indices

protectedinherited

Definition at line 279 of file fe_test.h.

_elem

Elem* FETestBase< order, family, elem_type, build_nx, Default >::_elem

protectedinherited

Definition at line 278 of file fe_test.h.

_es

std::unique_ptr<EquationSystems> FETestBase< order, family, elem_type, build_nx, Default >::_es

protectedinherited

Definition at line 282 of file fe_test.h.

_fe

std::unique_ptr<FEBase> FETestBase< order, family, elem_type, build_nx, Default >::_fe

protectedinherited

Definition at line 283 of file fe_test.h.

_fe_side

template<Order order, FEFamily family, ElemType elem_type>

std::unique_ptr<FEBase> FESideTest< order, family, elem_type >::_fe_side

private

Definition at line 44 of file fe_side_test.C.

Referenced by FESideTest< order, family, elem_type >::setUp(), and FESideTest< order, family, elem_type >::testSideLoop().

_grad_tol

Real FETestBase< order, family, elem_type, build_nx, Default >::_grad_tol

protectedinherited

Definition at line 286 of file fe_test.h.

_hess_tol

Real FETestBase< order, family, elem_type, build_nx, Default >::_hess_tol

protectedinherited

Definition at line 286 of file fe_test.h.

_mesh

std::unique_ptr<Mesh> FETestBase< order, family, elem_type, build_nx, Default >::_mesh

protectedinherited

Definition at line 281 of file fe_test.h.

_nx

unsigned int FETestBase< order, family, elem_type, build_nx, Default >::_nx

protectedinherited

Definition at line 277 of file fe_test.h.

_ny

unsigned int FETestBase< order, family, elem_type, build_nx, Default >::_ny

protectedinherited

Definition at line 277 of file fe_test.h.

_nz

unsigned int FETestBase< order, family, elem_type, build_nx, Default >::_nz

protectedinherited

Definition at line 277 of file fe_test.h.

_qrule

std::unique_ptr<QGauss> FETestBase< order, family, elem_type, build_nx, Default >::_qrule

protectedinherited

Definition at line 284 of file fe_test.h.

_qrule_side

template<Order order, FEFamily family, ElemType elem_type>

std::unique_ptr<QGauss> FESideTest< order, family, elem_type >::_qrule_side

private

Definition at line 45 of file fe_side_test.C.

Referenced by FESideTest< order, family, elem_type >::setUp().

_sys

System* FETestBase< order, family, elem_type, build_nx, Default >::_sys

protectedinherited

Definition at line 280 of file fe_test.h.

_value_tol

Real FETestBase< order, family, elem_type, build_nx, Default >::_value_tol

protectedinherited

Definition at line 286 of file fe_test.h.

libmesh_suite_name

std::string FETestBase< order, family, elem_type, build_nx, Default >::libmesh_suite_name

protectedinherited

Definition at line 272 of file fe_test.h.

---

The documentation for this class was generated from the following file:

• tests/fe/fe_side_test.C