6#include <libmesh/cell_c0polyhedron.h>
7#include <libmesh/dof_map.h>
8#include <libmesh/elem.h>
9#include <libmesh/equation_systems.h>
10#include <libmesh/face_c0polygon.h>
11#include <libmesh/fe.h>
12#include <libmesh/fe_base.h>
13#include <libmesh/fe_interface.h>
14#include <libmesh/function_base.h>
15#include <libmesh/mesh.h>
16#include <libmesh/mesh_generation.h>
17#include <libmesh/mesh_modification.h>
18#include <libmesh/numeric_vector.h>
19#include <libmesh/system.h>
20#include <libmesh/quadrature_gauss.h>
28 CPPUNIT_TEST( testFEInterface ); \
29 CPPUNIT_TEST( testRefspaceNodes ); \
30 CPPUNIT_TEST( testNodalSoln ); \
31 CPPUNIT_TEST( testU ); \
32 CPPUNIT_TEST( testPartitionOfUnity ); \
33 CPPUNIT_TEST( testUPastVertices ); \
34 CPPUNIT_TEST( testGradU ); \
35 CPPUNIT_TEST( testGradUPastVertices ); \
36 CPPUNIT_TEST( testGradUComp ); \
37 CPPUNIT_TEST( testHessU ); \
38 CPPUNIT_TEST( testHessUComp ); \
39 CPPUNIT_TEST( testDualDoesntScreamAndDie ); \
40 CPPUNIT_TEST( testCustomReinit );
47 std::unique_ptr<FunctionBase<Real>>
clone ()
const override
48 {
return std::make_unique<SkewFunc>(); }
51 const Real = 0.)
override
52 { libmesh_not_implemented(); }
79 const Real & x = p(0);
80 const Real & y = (LIBMESH_DIM > 1) ? p(1) : 0;
81 const Real & z = (LIBMESH_DIM > 2) ? p(2) : 0;
83 return x + 0.25*y + 0.0625*z;
108 const Real & x = p(0);
109 const Real & y = (LIBMESH_DIM > 1) ? p(1) : 0;
110 const Real & z = (LIBMESH_DIM > 2) ? p(2) : 0;
112 return x*x + 0.5*y*y + 0.25*z*z + 0.125*x*y + 0.0625*x*z + 0.03125*y*z;
121 const Real & x = p(0);
122 const Real & y = (LIBMESH_DIM > 1) ? p(1) : 0;
123 const Real & z = (LIBMESH_DIM > 2) ? p(2) : 0;
125 Gradient grad = 2*x + 0.125*y + 0.0625*z;
127 grad(1) = y + 0.125*x + 0.03125*z;
129 grad(2) = 0.5*z + 0.0625*x + 0.03125*y;
141 const Real & x = p(0);
142 const Real & y = (LIBMESH_DIM > 1) ? p(1) : 0;
143 const Real & z = (LIBMESH_DIM > 2) ? p(2) : 0;
145 return x*(1-x)*(1-x) + x*x*(1-y) + x*(1-y)*(1-z) + y*(1-y)*z + z*(1-z)*(1-z);
154 const Real & x = p(0);
155 const Real & y = (LIBMESH_DIM > 1) ? p(1) : 0;
156 const Real & z = (LIBMESH_DIM > 2) ? p(2) : 0;
158 Gradient grad = 3*x*x-4*x+1 + 2*x*(1-y) + (1-y)*(1-z);
160 grad(1) = -x*x - x*(1-z) + (1-2*y)*z;
162 grad(2) = -x*(1-y) + y*(1-y) + 3*z*z-4*z+1;
174 const Real & x = p(0);
175 const Real & y = (LIBMESH_DIM > 1) ? p(1) : 0;
176 const Real & z = (LIBMESH_DIM > 2) ? p(2) : 0;
178 return x*x*(1-x)*(1-x) + x*x*z*(1-y) + x*(1-x)*(1-y)*(1-z) + (1-x)*y*(1-y)*z + z*z*(1-z)*(1-z);
187 const Real & x = p(0);
188 const Real & y = (LIBMESH_DIM > 1) ? p(1) : 0;
189 const Real & z = (LIBMESH_DIM > 2) ? p(2) : 0;
191 Gradient grad = 4*x*x*x-6*x*x+2*x + 2*x*z*(1-y) + (1-2*x)*(1-y)*(1-z) - y*(1-y)*z;
193 grad(1) = -x*x*z - x*(1-x)*(1-z) + (1-x)*(1-2*y)*z;
195 grad(2) = x*x*(1-y) - x*(1-x)*(1-y) + (1-x)*y*(1-y) + 4*z*z*z-6*z*z+2*z;
213 const Real & x = p(0);
214 const Real & y = (LIBMESH_DIM > 1) ? p(1) : 0;
215 const Real & z = (LIBMESH_DIM > 2) ? p(2) : 0;
221 return (x + 0.25*y + 0.0625*z)/denom;
230 const Real & x = p(0);
231 const Real & y = (LIBMESH_DIM > 1) ? p(1) : 0;
232 const Real & z = (LIBMESH_DIM > 2) ? p(2) : 0;
241 const Real denom = xpoly * ypoly * zpoly;
243 const Real numer = (x + 0.25*y + 0.0625*z);
245 Gradient grad_n = 1, grad_d = xderiv * ypoly * zpoly;
249 grad_d(1) = xpoly * yderiv * zpoly;
254 grad_d(2) = xpoly * ypoly * zderiv;
257 Gradient grad = (grad_n - numer * grad_d / denom) / denom;
263#define FE_CAN_TEST_CUBIC \
264 (((family != LAGRANGE && family != L2_LAGRANGE) || \
265 (elem_type != TRI7 && elem_type != TET14 && \
266 elem_type != PRISM20 && elem_type != PRISM21 && \
267 elem_type != PYRAMID18)) && order > 2)
273template <Order order, FEFamily family, ElemType elem_type,
unsigned int build_nx,
typename CaseName = Default>
287 std::unique_ptr<EquationSystems>
_es;
288 std::unique_ptr<FEBase>
_fe;
311 else if (FE_CAN_TEST_CUBIC)
315 const Real & x = p(0);
316 const Real & y = (LIBMESH_DIM > 1) ? p(1) : 0;
317 const Real & z = (LIBMESH_DIM > 2) ? p(2) : 0;
319 true_grad =
Gradient(2*x+0.125*y+0.0625*z,
321 0.5*z+0.0625*x+0.03125*y);
324 true_grad =
Gradient(1.0, 0.25, 0.0625);
326 for (
unsigned int d=0; d != LIBMESH_DIM; ++d)
328 CPPUNIT_ASSERT(true_grad(d) ==
340 const Real & x = p(0);
341 const Real & y = LIBMESH_DIM > 1 ? p(1) : 0;
342 const Real & z = LIBMESH_DIM > 2 ? p(2) : 0;
346 { 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),
347 -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),
348 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 };
349 else if (FE_CAN_TEST_CUBIC)
351 { 6*x-4+2*(1-y), -2*x+z-1, y-1,
352 -2*x+z-1, -2*z, x+1-2*y,
353 y-1, x+1-2*y, 6*z-4 };
358 0.0625, 0.03125, 0.5 };
371 const unsigned int build_ny = (
_dim > 1) * build_nx;
372 const unsigned int build_nz = (
_dim > 2) * build_nx;
374 unsigned char weight_index = 0;
379 _mesh->add_node_integer(
"buffer integer");
383 const Real default_weight = 1.0;
384 weight_index = cast_int<unsigned char>
385 (
_mesh->add_node_datum<
Real>(
"rational_weight",
true,
387 libmesh_assert_not_equal_to(weight_index, 0);
392 _mesh->set_default_mapping_data(weight_index);
407 std::unique_ptr<Elem> polygon = std::make_unique<C0Polygon>(5);
409 polygon->set_node(i,
_mesh->node_ptr(i));
410 polygon->set_id() = 0;
412 _mesh->add_elem(std::move(polygon));
413 _mesh->prepare_for_use();
434 std::vector<std::vector<unsigned int>> nodes_on_side;
436 nodes_on_side = { {0, 1, 2, 3},
443 nodes_on_side = { {0, 1, 2, 3},
450 libmesh_error_msg(
"Unknown case name: " +
_case_name);
453 std::vector<std::shared_ptr<Polygon>> sides(nodes_on_side.size());
457 const auto & nodes_on_s = nodes_on_side[s];
458 sides[s] = std::make_shared<C0Polygon>(nodes_on_s.size());
460 sides[s]->set_node(i,
_mesh->node_ptr(nodes_on_s[i]));
463 std::unique_ptr<libMesh::Node> mid_elem_node;
464 std::unique_ptr<Elem> polyhedron = std::make_unique<C0Polyhedron>(sides, mid_elem_node);
465 _mesh->add_elem(std::move(polyhedron));
467 _mesh->add_node(std::move(mid_elem_node));
468 _mesh->prepare_for_use();
473 build_nx, build_ny, build_nz,
474 0., 1., 0., 1., 0., 1.,
485 if (elem && elem->
id())
486 _mesh->delete_elem(elem);
488 _mesh->prepare_for_use();
515 for (
auto elem :
_mesh->active_element_ptr_range())
521 const unsigned int nn = elem->n_nodes();
524 const unsigned int n_edges =
525 (elem->type() ==
EDGE3) ? 1 : elem->n_edges();
526 const unsigned int n_faces =
527 (elem->type() ==
QUAD9) ? 1 : elem->n_faces();
528 const unsigned int nve = std::min(nv + n_edges, nn);
529 const unsigned int nvef = std::min(nve + n_faces, nn);
531 for (
unsigned int i = 0; i != nv; ++i)
533 for (
unsigned int i = nv; i != nve; ++i)
536 for (
unsigned int i = nve; i != nvef; ++i)
539 for (
unsigned int i = nvef; i != nn; ++i)
544 _mesh->complete_preparation();
545 _es = std::make_unique<EquationSystems>(*
_mesh);
560 else if (FE_CAN_TEST_CUBIC)
578 _fe->attach_quadrature_rule(
_qrule.get());
580 auto rng =
_mesh->active_local_element_ptr_range();
581 this->_elem = rng.begin() == rng.end() ? nullptr : *(rng.begin());
603 this->_past_vertex_offset = 0.25;
612 Real t_prev = 1, t = x;
613 for (
unsigned int k = 1; k < static_cast<unsigned int>(order); ++k)
614 t_prev = std::exchange(t, 2 * x * t - t_prev);
615 this->_past_vertex_tol_factor = (order ==
CONSTANT) ? 1 : t;
628#if LIBMESH_ENABLE_SECOND_DERIVATIVES
637 _fe->get_d2phidxdy();
641 _fe->get_d2phidxdz();
642 _fe->get_d2phidydz();
654template <Order order, FEFamily family, ElemType elem_type,
typename CaseName>
659 template <
typename Functor>
671#ifdef LIBMESH_ENABLE_EXCEPTIONS
672 for (
unsigned int i=0; i != this->
_nx; ++i)
673 for (
unsigned int j=0; j != this->
_ny; ++j)
674 for (
unsigned int k=0; k != this->
_nz; ++k)
688 std::vector<Point> master_points
692 this->
_fe->reinit(this->
_elem, &master_points);
706 template <
typename Functor>
714 if (this->
_elem->
infinite() || this->_elem->runtime_topology())
720 std::vector<std::pair<unsigned int, unsigned int>> edges;
722 edges.emplace_back(0, 1);
724 edges.emplace_back(this->_elem->local_edge_node(e, 0),
733 for (
const auto & [a,
b] : edges)
739 std::vector<Point> master_points(1, master_p);
740 this->
_fe->reinit(this->
_elem, &master_points);
762 std::vector<Point> nodes;
763 this->
_fe->get_refspace_nodes(this->
_elem->
type(), nodes);
765 LIBMESH_ASSERT_REALVEC_EQUAL(nodes[n],
788 std::vector<Number> elem_soln(n_dofs, 0), nodal_soln;
793 elem_soln, nodal_soln);
796 CPPUNIT_ASSERT_EQUAL(std::size_t(this->
_elem->
n_nodes()),
799 LIBMESH_ASSERT_NUMBERS_EQUAL
815 bool satisfies_partition_of_unity =
true;
819 for (std::size_t d = 0; d != this->
_dof_indices.size(); ++d)
820 phi_sum += this->
_fe->get_phi()[d][qp];
823 satisfies_partition_of_unity =
false;
828 switch (this->
_fe->get_family())
832 switch (this->
_fe->get_order())
835 CPPUNIT_ASSERT(satisfies_partition_of_unity);
839 CPPUNIT_ASSERT(!satisfies_partition_of_unity);
848 switch (this->
_fe->get_order())
851 CPPUNIT_ASSERT(satisfies_partition_of_unity);
855 CPPUNIT_ASSERT(!satisfies_partition_of_unity);
865 CPPUNIT_ASSERT(!satisfies_partition_of_unity);
875 CPPUNIT_ASSERT(satisfies_partition_of_unity);
880 CPPUNIT_FAIL(
"Uncovered FEFamily");
897 unsigned int my_n_dofs = 0;
917 CPPUNIT_ASSERT_EQUAL(
921 CPPUNIT_ASSERT_EQUAL(
923 this->
_fe->get_continuity());
925 CPPUNIT_ASSERT_EQUAL(
927 this->
_fe->is_hierarchic());
934 return [
this, tol](
Point p)
939 for (std::size_t d = 0; d != this->
_dof_indices.size(); ++d)
948 else if (FE_CAN_TEST_CUBIC)
951 true_u = p(0)*p(0) + 0.5*p(1)*p(1) + 0.25*p(2)*p(2) +
952 0.125*p(0)*p(1) + 0.0625*p(0)*p(2) + 0.03125*p(1)*p(2);
954 true_u = p(0) + 0.25*p(1) + 0.0625*p(2);
956 LIBMESH_ASSERT_NUMBERS_EQUAL (true_u, u, tol);
981 this->
_fe->get_dual_phi();
992 return [
this, tol](
Point p)
997 for (std::size_t d = 0; d != this->
_dof_indices.size(); ++d)
1002 LIBMESH_ASSERT_NUMBERS_EQUAL
1003 (grad_u(0), true_grad(0), tol);
1005 LIBMESH_ASSERT_NUMBERS_EQUAL
1006 (grad_u(1), true_grad(1), tol);
1008 LIBMESH_ASSERT_NUMBERS_EQUAL
1009 (grad_u(2), true_grad(2), tol);
1029 auto f = [
this](
Point p)
1033 Number grad_u_x = 0, grad_u_y = 0, grad_u_z = 0;
1034 for (std::size_t d = 0; d != this->
_dof_indices.size(); ++d)
1047 LIBMESH_ASSERT_NUMBERS_EQUAL(grad_u_x,
1050 LIBMESH_ASSERT_NUMBERS_EQUAL
1051 (grad_u_y, true_grad(1), this->
_grad_tol);
1053 LIBMESH_ASSERT_NUMBERS_EQUAL
1054 (grad_u_z, true_grad(2), this->
_grad_tol);
1069#ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
1070 auto f = [
this](
Point p)
1073 for (std::size_t d = 0; d != this->
_dof_indices.size(); ++d)
1082 LIBMESH_ASSERT_NUMBERS_EQUAL
1083 (true_hess(0,0), hess_u(0,0), this->
_hess_tol);
1086 LIBMESH_ASSERT_NUMBERS_EQUAL
1087 (hess_u(0,1), hess_u(1,0), this->
_hess_tol);
1088 LIBMESH_ASSERT_NUMBERS_EQUAL
1089 (true_hess(0,1), hess_u(0,1), this->
_hess_tol);
1090 LIBMESH_ASSERT_NUMBERS_EQUAL
1091 (true_hess(1,1), hess_u(1,1), this->
_hess_tol);
1095 LIBMESH_ASSERT_NUMBERS_EQUAL
1096 (hess_u(0,2), hess_u(2,0), this->
_hess_tol);
1097 LIBMESH_ASSERT_NUMBERS_EQUAL
1098 (hess_u(1,2), hess_u(2,1), this->
_hess_tol);
1099 LIBMESH_ASSERT_NUMBERS_EQUAL
1100 (true_hess(0,2), hess_u(0,2), this->
_hess_tol);
1101 LIBMESH_ASSERT_NUMBERS_EQUAL
1102 (true_hess(1,2), hess_u(1,2), this->
_hess_tol);
1103 LIBMESH_ASSERT_NUMBERS_EQUAL
1104 (true_hess(2,2), hess_u(2,2), this->
_hess_tol);
1114#ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
1121 auto f = [
this](
Point p)
1123 Number hess_u_xx = 0, hess_u_xy = 0, hess_u_yy = 0,
1124 hess_u_xz = 0, hess_u_yz = 0, hess_u_zz = 0;
1125 for (std::size_t d = 0; d != this->
_dof_indices.size(); ++d)
1145 LIBMESH_ASSERT_NUMBERS_EQUAL
1146 (true_hess(0,0), hess_u_xx, this->
_hess_tol);
1149 LIBMESH_ASSERT_NUMBERS_EQUAL
1150 (true_hess(0,1), hess_u_xy, this->
_hess_tol);
1151 LIBMESH_ASSERT_NUMBERS_EQUAL
1152 (true_hess(1,1), hess_u_yy, this->
_hess_tol);
1156 LIBMESH_ASSERT_NUMBERS_EQUAL
1157 (true_hess(0,2), hess_u_xz, this->
_hess_tol);
1158 LIBMESH_ASSERT_NUMBERS_EQUAL
1159 (true_hess(1,2), hess_u_yz, this->
_hess_tol);
1160 LIBMESH_ASSERT_NUMBERS_EQUAL
1161 (true_hess(2,2), hess_u_zz, this->
_hess_tol);
1173 std::vector<Point> q_points;
1174 std::vector<Real> weights;
1175 q_points.resize(3); weights.resize(3);
1176 q_points[0](0) = 0.0; q_points[0](1) = 0.0; weights[0] =
Real(1)/6;
1177 q_points[1](0) = 1.0; q_points[1](1) = 0.0; weights[1] = weights[0];
1178 q_points[2](0) = 0.0; q_points[2](1) = 1.0; weights[2] = weights[0];
1182 const int extraorder = 3;
1184 fe->attach_quadrature_rule (qrule.get());
1186 const std::vector<Point> & q_pos = fe->get_xyz();
1188 for (
const auto & elem : this->
_mesh->active_local_element_ptr_range()) {
1189 fe->reinit (elem, &q_points, &weights);
1190 CPPUNIT_ASSERT_EQUAL(q_points.size(), std::size_t(3));
1191 CPPUNIT_ASSERT_EQUAL(q_pos.size(), std::size_t(3));
1198#define INSTANTIATE_FETEST_CASE(order, family, elemtype, case_name) \
1199 class FETest_##order##_##family##_##elemtype##_##case_name : public FETest<order, family, elemtype, case_name> { \
1201 FETest_##order##_##family##_##elemtype##_##case_name() : \
1202 FETest<order,family,elemtype,case_name>() { \
1203 if (unitlog->summarized_logs_enabled()) \
1204 this->libmesh_suite_name = "FETest"; \
1206 this->libmesh_suite_name = "FETest_" #order "_" #family "_" #elemtype "_" #case_name; \
1207 this->_case_name = #case_name; \
1209 CPPUNIT_TEST_SUITE( FETest_##order##_##family##_##elemtype##_##case_name ); \
1211 CPPUNIT_TEST_SUITE_END(); \
1214 CPPUNIT_TEST_SUITE_REGISTRATION( FETest_##order##_##family##_##elemtype##_##case_name );
1216#define INSTANTIATE_FETEST(order, family, elemtype) \
1217 INSTANTIATE_FETEST_CASE(order, family, elemtype, Default)
Real _past_vertex_tol_factor
The factor by which the tolerances grow at the points past the vertices.
std::string _case_name
Name of the case, can be used in the test to switch cases.
std::string libmesh_suite_name
std::unique_ptr< EquationSystems > _es
std::unique_ptr< FEBase > _fe
std::unique_ptr< Mesh > _mesh
std::vector< dof_id_type > _dof_indices
std::unique_ptr< QGauss > _qrule
static RealTensor true_hessian(Point p)
Real _past_vertex_offset
The offset, as a fraction of an edge, of the points past the vertices.
static RealGradient true_gradient(Point p)
void testGradUPastVertices()
void testPartitionOfUnity()
void testDualDoesntScreamAndDie()
auto checkU(const Real tol)
auto checkGradU(const Real tol)
void testPastVerticesLoop(Functor f)
Real operator()(const Point &, const Real=0.) override
std::unique_ptr< FunctionBase< Real > > clone() const override
Defines a dense vector for use in Finite Element-type computations.
void resize(const unsigned int n)
Resize the vector.
void dof_indices(const Elem *const elem, std::vector< dof_id_type > &di) const
void set_extra_datum(const unsigned int index, const T value)
Sets the value on this object of the extra datum associated with index, which should have been obtain...
This is the base class from which all geometric element types are derived.
virtual unsigned int n_vertices() const =0
const Node & node_ref(const unsigned int i) const
virtual unsigned int n_nodes() const =0
virtual bool is_singular_node(unsigned int) const
virtual bool contains_point(const Point &p, Real tol=TOLERANCE) const
virtual unsigned short dim() const =0
virtual unsigned int local_edge_node(unsigned int edge, unsigned int edge_node) const =0
Similar to Elem::local_side_node(), but instead of a side id, takes an edge id and a node id on that ...
static const unsigned int type_to_dim_map[INVALID_ELEM]
This array maps the integer representation of the ElemType enum to the geometric dimension of the ele...
virtual bool runtime_topology() const
IntRange< unsigned short > edge_index_range() const
virtual ElemType type() const =0
IntRange< unsigned short > node_index_range() const
virtual Point master_point(const unsigned int i) const =0
virtual unsigned int local_singular_node(const Point &, const Real=TOLERANCE *TOLERANCE) const
virtual bool infinite() const =0
static std::unique_ptr< FEGenericBase > build(const unsigned int dim, const FEType &type)
Builds a specific finite element type.
static Real shape(const unsigned int dim, const FEType &fe_t, const ElemType t, const unsigned int i, const Point &p)
static bool is_hierarchic(const FEType &fe_type)
Returns whether or not the input FEType's higher-order shape functions are always hierarchic.
static FEContinuity get_continuity(const FEType &fe_type)
Returns the input FEType's FEContinuity based on the underlying FEFamily and potentially the Order,...
static unsigned int n_dofs(const unsigned int dim, const FEType &fe_t, const ElemType t)
static void nodal_soln(const unsigned int dim, const FEType &fe_t, const Elem *elem, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln, const bool add_p_level=true, const unsigned int vdim=1)
Build the nodal soln from the element soln.
static unsigned int n_shape_functions(const unsigned int dim, const FEType &fe_t, const ElemType t)
static Point map(const unsigned int dim, const Elem *elem, const Point &reference_point)
static Point inverse_map(const unsigned int dim, const Elem *elem, const Point &p, const Real tolerance=TOLERANCE, const bool secure=true, const bool extra_checks=true)
class FEType hides (possibly multiple) FEFamily and approximation orders, thereby enabling specialize...
std::unique_ptr< QBase > default_quadrature_rule(const unsigned int dim, const int extraorder=0) const
Order default_quadrature_order() const
static unsigned int n_dofs(const ElemType t, const Order o)
Base class for functors that can be evaluated at a point and (optionally) time.
This class provides the ability to map between arbitrary, user-defined strings and several data types...
A Point defines a location in LIBMESH_DIM dimensional Real space.
Manages consistently variables, degrees of freedom, and coefficient vectors.
void project_solution(FunctionBase< Number > *f, FunctionBase< Gradient > *g=nullptr, std::optional< ConstElemRange > active_local_range=std::nullopt, std::optional< std::vector< unsigned int > > variable_numbers=std::nullopt) const
Projects arbitrary functions onto the current solution.
std::unique_ptr< NumericVector< Number > > current_local_solution
All the values I need to compute my contribution to the simulation at hand.
const FEType & variable_type(const unsigned int i) const
unsigned int add_variable(std::string_view var, const FEType &type, const std::set< subdomain_id_type > *const active_subdomains=nullptr)
Adds the variable var to the list of variables for this system.
const DofMap & get_dof_map() const
This class defines a tensor in LIBMESH_DIM dimensional Real or Complex space.
This class defines a vector in LIBMESH_DIM dimensional Real or Complex space.
Communicator * TestCommWorld
static const Real rational_w
Number fe_cubic_test(const Point &p, const Parameters &, const std::string &, const std::string &)
Number rational_test(const Point &p, const Parameters &, const std::string &, const std::string &)
Gradient quadratic_test_grad(const Point &p, const Parameters &, const std::string &, const std::string &)
Number quadratic_test(const Point &p, const Parameters &, const std::string &, const std::string &)
Gradient fe_quartic_test_grad(const Point &p, const Parameters &, const std::string &, const std::string &)
Gradient linear_test_grad(const Point &, const Parameters &, const std::string &, const std::string &)
Number fe_quartic_test(const Point &p, const Parameters &, const std::string &, const std::string &)
Gradient rational_test_grad(const Point &p, const Parameters &, const std::string &, const std::string &)
Gradient fe_cubic_test_grad(const Point &p, const Parameters &, const std::string &, const std::string &)
Number linear_test(const Point &p, const Parameters &, const std::string &, const std::string &)
The libMesh namespace provides an interface to certain functionality in the library.
auto index_range(const T &sizable)
Helper function that returns an IntRange<std::size_t> representing all the indices of the passed-in v...
NumberVectorValue Gradient
const unsigned int invalid_uint
A number which is used quite often to represent an invalid or uninitialized value for an unsigned int...
LIBMESH_DEVICE_INLINE T libmesh_real(T a)
static constexpr Real TOLERANCE
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
IntRange< T > make_range(T beg, T end)
The 2-parameter make_range() helper function returns an IntRange<T> when both input parameters are of...