libMesh::QComposite< QSubCell > Class Template Reference

This class implements generic composite quadrature rules. More...

#include <quadrature_composite.h>

Inheritance diagram for libMesh::QComposite< QSubCell >:

Public Member Functions
	QComposite (unsigned int dim, Order order=INVALID_ORDER)
	Constructor.
	QComposite (const QComposite &)=delete
	This class contains a unique_ptr member, so it can't be default copy constructed or assigned.
QComposite &	operator= (const QComposite &)=delete
	QComposite (QComposite &&)=default
	Copy/move ctor, copy/move assignment operator, and destructor are all explicitly defaulted for this simple class.
QComposite &	operator= (QComposite &&)=default
virtual	~QComposite ()=default
virtual QuadratureType	type () const override
virtual void	init (const Elem &elem, const std::vector< Real > &vertex_distance_func, unsigned int p_level=0) override
	Overrides the base class init() function, and uses the ElemCutter to subdivide the element into "inside" and "outside" subelements.

Private Member Functions
void	add_subelem_values (const std::vector< Elem const * > &subelem)
	Helper function called from init() to collect all the points and weights of the subelement quadrature rules.

Private Attributes
QSubCell	_q_subcell
	Subcell quadrature object.
ElemCutter	_elem_cutter
	ElemCutter object.
std::unique_ptr< FEBase >	_lagrange_fe
	Lagrange FE to use for subcell mapping.

Detailed Description

template<class QSubCell>
class libMesh::QComposite< QSubCell >

This class implements generic composite quadrature rules.

Composite quadrature rules are constructed from any of the supported rules by breaking an element into subelements and applying the base rule on each subelement. This class uses the ElemCutter, which is only available if libmesh is configured with –disable-strict-lgpl.

Author

Benjamin Kirk

Date

2013

A quadrature rule for subdivided elements.

Definition at line 51 of file quadrature_composite.h.

Constructor & Destructor Documentation

QComposite() [1/3]

template<class QSubCell >

libMesh::QComposite< QSubCell >::QComposite	(	unsigned int	dim,
		Order	order = INVALID_ORDER
	)

Constructor.

Declares the order of the quadrature rule.

Definition at line 45 of file quadrature_composite.C.

                                          :
  QSubCell(d,o), // explicitly call base class constructor
  _q_subcell(d,o),
  _lagrange_fe(FEBase::build (d, FEType (FIRST, LAGRANGE)))
{
  // explicitly call the init function in 1D since the
  // other tensor-product rules require this one.
  // note that EDGE will not be used internally, however
  // if we called the function with INVALID_ELEM it would try to
  // be smart and return, thinking it had already done the work.
  if (_dim == 1)
    QSubCell::init(EDGE2);
 
  libmesh_assert (_lagrange_fe.get() != nullptr);
 
  _lagrange_fe->attach_quadrature_rule (&_q_subcell);
}

References libMesh::QComposite< QSubCell >::_lagrange_fe, libMesh::QComposite< QSubCell >::_q_subcell, libMesh::EDGE2, and libMesh::libmesh_assert().

QComposite() [2/3]

template<class QSubCell >

libMesh::QComposite< QSubCell >::QComposite ( const QComposite< QSubCell > &  )

delete

This class contains a unique_ptr member, so it can't be default copy constructed or assigned.

QComposite() [3/3]

template<class QSubCell >

libMesh::QComposite< QSubCell >::QComposite ( QComposite< QSubCell > &&  )

default

Copy/move ctor, copy/move assignment operator, and destructor are all explicitly defaulted for this simple class.

~QComposite()

template<class QSubCell >

virtual libMesh::QComposite< QSubCell >::~QComposite ( )

virtualdefault

Member Function Documentation

add_subelem_values()

template<class QSubCell >

void libMesh::QComposite< QSubCell >::add_subelem_values ( const std::vector< Elem const * > &  subelem )

private

Helper function called from init() to collect all the points and weights of the subelement quadrature rules.

Definition at line 127 of file quadrature_composite.C.

{
  const std::vector<Real>  & subelem_weights = _lagrange_fe->get_JxW();
  const std::vector<Point> & subelem_points  = _lagrange_fe->get_xyz();
 
  for (const auto & elem : subelem)
    {
      // tetgen seems to create 0-volume cells on occasion, but we *should*
      // be catching that appropriately now inside the ElemCutter class.
      // Just in case trap here, describe the error, and abort.
      libmesh_try
        {
          _lagrange_fe->reinit(elem);
          _weights.insert(_weights.end(),
                          subelem_weights.begin(), subelem_weights.end());
 
          _points.insert(_points.end(),
                         subelem_points.begin(), subelem_points.end());
        }
      libmesh_catch (...)
        {
          libMesh::err << "ERROR: found a bad cut cell!\n";
 
          for (auto n : elem->node_index_range())
            libMesh::err << elem->point(n) << std::endl;
 
          libmesh_error_msg("Tetgen may have created a 0-volume cell during Cutcell integration.");
        }
    }
}

References libMesh::err.

init()

template<class QSubCell >

void libMesh::QComposite< QSubCell >::init ( const Elem &  elem, const std::vector< Real > &  vertex_distance_func, unsigned int  p_level = 0  )

overridevirtual

Overrides the base class init() function, and uses the ElemCutter to subdivide the element into "inside" and "outside" subelements.

Definition at line 67 of file quadrature_composite.C.

{
  libmesh_assert_equal_to (vertex_distance_func.size(), elem.n_vertices());
  libmesh_assert_equal_to (_dim, elem.dim());
 
  // We already initialized a Lagrange map; we're not supporting
  // others yet
  libmesh_assert_equal_to (elem.mapping_type(), LAGRANGE_MAP);
 
  // if we are not cut, revert to simple base class init() method.
  if (!_elem_cutter.is_cut (elem, vertex_distance_func))
    {
      _q_subcell.init (elem, p_level);
      _points  = _q_subcell.get_points();
      _weights = _q_subcell.get_weights();
 
      //this->print_info();
      return;
    }
 
  // Get a pointer to the element's reference element.  We want to
  // perform cutting on the reference element such that the quadrature
  // point locations of the subelements live in the reference
  // coordinate system, thereby eliminating the need for inverse
  // mapping.
  const Elem * reference_elem = elem.reference_elem();
 
  libmesh_assert (reference_elem != nullptr);
 
  _elem_cutter(*reference_elem, vertex_distance_func);
  //_elem_cutter(elem, vertex_distance_func);
 
  // clear our state & accumulate points from subelements
  _points.clear();
  _weights.clear();
 
  // inside subelem
  {
    const std::vector<Elem const *> & inside_elem (_elem_cutter.inside_elements());
    // std::cout << inside_elem.size() << " elements inside\n";
 
    this->add_subelem_values(inside_elem);
  }
 
  // outside subelem
  {
    const std::vector<Elem const *> & outside_elem (_elem_cutter.outside_elements());
    // std::cout << outside_elem.size() << " elements outside\n";
 
    this->add_subelem_values(outside_elem);
  }
 
  // this->print_info();
}

References libMesh::Elem::dim(), libMesh::LAGRANGE_MAP, libMesh::libmesh_assert(), libMesh::Elem::mapping_type(), libMesh::Elem::n_vertices(), and libMesh::Elem::reference_elem().

Referenced by integrate_function().

operator=() [1/2]

template<class QSubCell >

QComposite & libMesh::QComposite< QSubCell >::operator= ( const QComposite< QSubCell > &  )

delete

operator=() [2/2]

template<class QSubCell >

QComposite & libMesh::QComposite< QSubCell >::operator= ( QComposite< QSubCell > &&  )

default

type()

template<class QSubCell >

QuadratureType libMesh::QComposite< QSubCell >::type ( ) const

overridevirtual

Returns

QCOMPOSITE.

Definition at line 37 of file quadrature_composite.C.

{
  return QCOMPOSITE;
}

References libMesh::QCOMPOSITE.

Member Data Documentation

_elem_cutter

template<class QSubCell >

ElemCutter libMesh::QComposite< QSubCell >::_elem_cutter

private

ElemCutter object.

Definition at line 113 of file quadrature_composite.h.

_lagrange_fe

template<class QSubCell >

std::unique_ptr<FEBase> libMesh::QComposite< QSubCell >::_lagrange_fe

private

Lagrange FE to use for subcell mapping.

Definition at line 118 of file quadrature_composite.h.

Referenced by libMesh::QComposite< QSubCell >::QComposite().

_q_subcell

template<class QSubCell >

QSubCell libMesh::QComposite< QSubCell >::_q_subcell

private

Subcell quadrature object.

Definition at line 108 of file quadrature_composite.h.

Referenced by libMesh::QComposite< QSubCell >::QComposite().

---

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

• include/quadrature/quadrature_composite.h
• src/quadrature/quadrature_composite.C