void integrate_function (const MeshBase &mesh)
{
#if defined(LIBMESH_HAVE_TRIANGLE) && defined(LIBMESH_HAVE_TETGEN)
MeshBase::const_element_iterator el = mesh.active_local_elements_begin();
const MeshBase::const_element_iterator end_el = mesh.active_local_elements_end();
std::vector<Real> vertex_distance;
QComposite<QGauss> qrule (mesh.mesh_dimension(), FIRST);
//QGauss qrule (mesh.mesh_dimension(), FIRST);
UniquePtr<FEBase> fe (FEBase::build (mesh.mesh_dimension(), FEType (FIRST, LAGRANGE)));
Real int_val=0.;
const std::vector<Point> &q_points = fe->get_xyz();
const std::vector<Real> &JxW = fe->get_JxW();
for (; el!=end_el; ++el)
{
const Elem *elem = *el;
vertex_distance.clear();
for (unsigned int v=0; v<elem->n_vertices(); v++)
vertex_distance.push_back (distance(elem->point(v)));
qrule.init (*elem, vertex_distance);
fe->reinit (elem,
&(qrule.get_points()),
&(qrule.get_weights()));
// TODO: would it be valuable to have the composite quadrature rule sort
// from smallest to largest JxW value to help prevent
// ... large + small + large + large + small ...
// type truncation errors?
for (unsigned int qp=0; qp<q_points.size(); qp++)
int_val += JxW[qp] * integrand(q_points[qp]);
}
mesh.comm().sum (int_val);
std::cout << "\n***********************************\n"
<< " int_val = " << int_val << std::endl
<< " exact_val = " << 1*(2*2 - radius*radius*pi) + 10.*(radius*radius*pi)
<< "\n***********************************\n"
<< std::endl;
#else
libmesh_ignore(mesh);
#endif
}
void
SideSetsGeneratorBase::setup(MeshBase & mesh)
{
mooseAssert(_fe_face == nullptr, "FE Face has already been initialized");
unsigned int dim = mesh.mesh_dimension();
// Setup the FE Object so we can calculate normals
FEType fe_type(Utility::string_to_enum<Order>("CONSTANT"),
Utility::string_to_enum<FEFamily>("MONOMIAL"));
_fe_face = FEBase::build(dim, fe_type);
_qface = libmesh_make_unique<QGauss>(dim - 1, FIRST);
_fe_face->attach_quadrature_rule(_qface.get());
}
