QUESO::TensorProductQuadrature< V, M > Class Template Reference

Numerical quadrature using a tensor product of Base1DQuadrature rules. More...

#include <TensorProductQuadrature.h>

Inheritance diagram for QUESO::TensorProductQuadrature< V, M >:

Public Member Functions
	TensorProductQuadrature (const VectorSubset< V, M > &domain, const std::vector< QUESO::SharedPtr< Base1DQuadrature >::Type > &q_rules)
virtual	~TensorProductQuadrature ()
Public Member Functions inherited from QUESO::MultiDQuadratureBase< V, M >
	MultiDQuadratureBase (const VectorSubset< V, M > &domain)
virtual	~MultiDQuadratureBase ()=0
	Pure virtual destructor, forcing this to be an abstract object. More...
const std::vector< typename QUESO::SharedPtr< V >::Type > &	positions () const
const VectorSubset< V, M > &	getDomain () const
Public Member Functions inherited from QUESO::BaseQuadrature
	BaseQuadrature ()
virtual	~BaseQuadrature ()=0
	Pure virtual destructor, forcing this to be an abstract object. More...
const std::vector< double > &	weights () const
	Array of the weights used in the numerical integration. More...

Additional Inherited Members
Protected Attributes inherited from QUESO::MultiDQuadratureBase< V, M >
std::vector< typename QUESO::SharedPtr< V >::Type >	m_positions
	Locations of quadrature points. More...
const VectorSubset< V, M > &	m_domain
	Domain over which the quadrature will be performed. More...
Protected Attributes inherited from QUESO::BaseQuadrature
std::vector< double >	m_weights

Detailed Description

template<class V = GslVector, class M = GslMatrix>
class QUESO::TensorProductQuadrature< V, M >

Numerical quadrature using a tensor product of Base1DQuadrature rules.

The user constructs a vector of Base1DQuadrature rules from which this class will construct a multi-dimensional quadrature rule using a tensor product of the one-dimensional rules. Thus, the dimension of this tensor product rule will be the size of the vector of one-dimensional rules provided by the user and, therefore, should match the dimension of the domain also supplied by the user.

Definition at line 47 of file TensorProductQuadrature.h.

Constructor & Destructor Documentation

template<class V , class M >

QUESO::TensorProductQuadrature< V, M >::TensorProductQuadrature	(	const VectorSubset< V, M > &	domain,
		const std::vector< QUESO::SharedPtr< Base1DQuadrature >::Type > &	q_rules
	)

Definition at line 36 of file TensorProductQuadrature.C.

References dim, QUESO::MultiDimensionalIndexing::globalToCoord(), QUESO::MultiDQuadratureBase< V, M >::m_positions, QUESO::BaseQuadrature::m_weights, QUESO::queso_require_equal_to_msg, and QUESO::VectorSubset< V, M >::vectorSpace().

    : MultiDQuadratureBase<V,M>(domain)
  {
    const unsigned int dim = domain.vectorSpace().dimGlobal();

    queso_require_equal_to_msg(dim, q_rules.size(), "Mismatched quadrature rule size and vector space dimension!");

    // We figure the number of q_points in each dimension and the total
    unsigned int total_n_q_points = 1;
    std::vector<unsigned int> n_q_points(dim);
    for( unsigned int i = 0; i < dim; i++ )
      {
        n_q_points[i] = q_rules[i]->positions().size();
        total_n_q_points *= q_rules[i]->positions().size();
      }

    this->m_positions.resize(total_n_q_points,SharedPtr<GslVector>::Type());
    this->m_weights.resize(total_n_q_points);

    // The positions are just a tensor product of the positions for each of the 1-D rules.
    // Thus, we leverage the MultiDimensionalIndexing to move from "global" quadrature point
    // number to the index in each of the dimensions. Each of these dimensional indices tells
    // us which component of the corresponding 1-D rule to extract.
    // The final quadrature weight will be the product of each of the corresponding weights
    // for the 1-D rule, with the correspondence dictated by the "local" index in that dimension
    // (as with the position).
    std::vector<unsigned int> indices(dim);
    for( unsigned int q = 0; q < total_n_q_points; q++ )
      {
        MultiDimensionalIndexing::globalToCoord( q, n_q_points, indices );

        // Make sure indices size isn't something we don't expect after population
        queso_assert_equal_to(indices.size(),dim);

        // Create new vector from our vector space
        // We are taking ownership of this pointer.
        typename QUESO::SharedPtr<V>::Type domain_vec(domain.vectorSpace().newVector());

        // Now populate the weights and positions
        double weight = 1.0;
        for( unsigned int i = 0; i < dim; i++ )
          {
            unsigned int idx = indices[i];
            (*domain_vec)[i] = q_rules[i]->positions()[idx];
            weight *= q_rules[i]->weights()[idx];
          }

        // m_positions is taking ownership of the V*
        this->m_positions[q] = domain_vec;
        this->m_weights[q] = weight;
      }
  }

template<class V = GslVector, class M = GslMatrix>

virtual QUESO::TensorProductQuadrature< V, M >::~TensorProductQuadrature ( )

inlinevirtual

Definition at line 54 of file TensorProductQuadrature.h.

{}

---

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

• src/misc/inc/TensorProductQuadrature.h
• src/misc/src/TensorProductQuadrature.C