libMesh::QComposite< QSubCell > Class Template Reference

A quadrature rule for subdivided elements. More...

#include <quadrature_composite.h>

Inheritance diagram for libMesh::QComposite< QSubCell >:

Public Member Functions
	QComposite (unsigned int dim, Order order=INVALID_ORDER)
	QComposite (const QComposite &)=delete
QComposite &	operator= (const QComposite &)=delete
	QComposite (QComposite &&)=default
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

Private Member Functions
void	add_subelem_values (const std::vector< Elem const *> &subelem)

Private Attributes
QSubCell	_q_subcell
ElemCutter	_elem_cutter
std::unique_ptr< FEBase >	_lagrange_fe

Detailed Description

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

A quadrature rule for subdivided elements.

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

Definition at line 52 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.

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

                                          :
  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);
}

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 123 of file quadrature_composite.C.

References libMesh::err.

{
  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 (unsigned int n=0; n<elem->n_nodes(); n++)
            libMesh::err << elem->point(n) << std::endl;

          libmesh_error_msg("Tetgen may have created a 0-volume cell during Cutcell integration.");
        }
    }
}

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.

References libMesh::Elem::dim(), libMesh::Elem::n_vertices(), libMesh::Elem::reference_elem(), and libMesh::Elem::type().

{
  libmesh_assert_equal_to (vertex_distance_func.size(), elem.n_vertices());
  libmesh_assert_equal_to (_dim, elem.dim());

  // 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.type(), 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();
}

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.

References libMesh::QCOMPOSITE.

{
  return QCOMPOSITE;
}

Member Data Documentation

_elem_cutter

template<class QSubCell >

ElemCutter libMesh::QComposite< QSubCell >::_elem_cutter

private

ElemCutter object.

Definition at line 114 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 119 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 109 of file quadrature_composite.h.

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

---

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

• quadrature_composite.h
• quadrature_composite.C