Reference documentation for deal.II version 8.1.0
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Groups Pages
quadrature.h
1 // ---------------------------------------------------------------------
2 // @f$Id: quadrature.h 31772 2013-11-23 08:02:51Z kanschat @f$
3 //
4 // Copyright (C) 1998 - 2013 by the deal.II authors
5 //
6 // This file is part of the deal.II library.
7 //
8 // The deal.II library is free software; you can use it, redistribute
9 // it, and/or modify it under the terms of the GNU Lesser General
10 // Public License as published by the Free Software Foundation; either
11 // version 2.1 of the License, or (at your option) any later version.
12 // The full text of the license can be found in the file LICENSE at
13 // the top level of the deal.II distribution.
14 //
15 // ---------------------------------------------------------------------
16 
17 #ifndef __deal2__quadrature_h
18 #define __deal2__quadrature_h
19 
20 
21 #include <deal.II/base/config.h>
22 #include <deal.II/base/point.h>
23 #include <deal.II/base/subscriptor.h>
24 #include <vector>
25 
26 DEAL_II_NAMESPACE_OPEN
27 
30 
84 template <int dim>
85 class Quadrature : public Subscriptor
86 {
87 public:
95  typedef Quadrature<dim-1> SubQuadrature;
96 
109  explicit Quadrature (const unsigned int n_quadrature_points = 0);
110 
122  Quadrature (const SubQuadrature &,
123  const Quadrature<1> &);
124 
146  explicit Quadrature (const Quadrature<dim != 1 ? 1 : 0> &quadrature_1d);
147 
151  Quadrature (const Quadrature<dim> &q);
152 
163  Quadrature (const std::vector<Point<dim> > &points,
164  const std::vector<double> &weights);
165 
181  Quadrature (const std::vector<Point<dim> > &points);
182 
188  Quadrature (const Point<dim> &point);
189 
193  virtual ~Quadrature ();
194 
202 
206  bool operator == (const Quadrature<dim> &p) const;
207 
213  void initialize(const std::vector<Point<dim> > &points,
214  const std::vector<double> &weights);
215 
219  unsigned int size () const;
220 
225  const Point<dim> &point (const unsigned int i) const;
226 
232  const std::vector<Point<dim> > &get_points () const;
233 
238  double weight (const unsigned int i) const;
239 
244  const std::vector<double> &get_weights () const;
245 
252  std::size_t memory_consumption () const;
253 
258  template <class Archive>
259  void serialize (Archive &ar, const unsigned int version);
260 
261 protected:
267  std::vector<Point<dim> > quadrature_points;
268 
275  std::vector<double> weights;
276 };
277 
278 
290 template <int dim>
291 class QAnisotropic : public Quadrature<dim>
292 {
293 public:
300  QAnisotropic(const Quadrature<1> &qx);
301 
306  QAnisotropic(const Quadrature<1> &qx,
307  const Quadrature<1> &qy);
308 
313  QAnisotropic(const Quadrature<1> &qx,
314  const Quadrature<1> &qy,
315  const Quadrature<1> &qz);
316 };
317 
318 
344 template <int dim>
345 class QIterated : public Quadrature<dim>
346 {
347 public:
353  QIterated (const Quadrature<1> &base_quadrature,
354  const unsigned int n_copies);
355 
359  DeclException0 (ExcInvalidQuadratureFormula);
360 private:
367  static bool
368  uses_both_endpoints (const Quadrature<1> &base_quadrature);
369 };
370 
371 
372 
375 #ifndef DOXYGEN
376 
377 // ------------------- inline and template functions ----------------
378 
379 
380 template<int dim>
381 inline
382 unsigned int
383 Quadrature<dim>::size () const
384 {
385  return weights.size();
386 }
387 
388 
389 template <int dim>
390 inline
391 const Point<dim> &
392 Quadrature<dim>::point (const unsigned int i) const
393 {
394  AssertIndexRange(i, size());
395  return quadrature_points[i];
396 }
397 
398 
399 
400 template <int dim>
401 double
402 Quadrature<dim>::weight (const unsigned int i) const
403 {
404  AssertIndexRange(i, size());
405  return weights[i];
406 }
407 
408 
409 
410 template <int dim>
411 inline
412 const std::vector<Point<dim> > &
414 {
415  return quadrature_points;
416 }
417 
418 
419 
420 template <int dim>
421 inline
422 const std::vector<double> &
424 {
425  return weights;
426 }
427 
428 
429 
430 template <int dim>
431 template <class Archive>
432 inline
433 void
434 Quadrature<dim>::serialize (Archive &ar, const unsigned int)
435 {
436  // forward to serialization
437  // function in the base class.
438  ar &static_cast<Subscriptor &>(*this);
439 
441 }
442 
443 
444 
445 /* -------------- declaration of explicit specializations ------------- */
446 
447 template <>
448 Quadrature<0>::Quadrature (const unsigned int);
449 template <>
451  const Quadrature<1> &);
452 template <>
454 template <>
456 
457 template <>
459  const Quadrature<1> &);
460 
461 template <>
463 
464 #endif // DOXYGEN
465 DEAL_II_NAMESPACE_CLOSE
466 
467 #endif
Quadrature & operator=(const Quadrature< dim > &)
const std::vector< double > & get_weights() const
Quadrature< dim-1 > SubQuadrature
Definition: quadrature.h:95
#define AssertIndexRange(index, range)
Definition: exceptions.h:888
static bool uses_both_endpoints(const Quadrature< 1 > &base_quadrature)
bool operator==(const Quadrature< dim > &p) const
const std::vector< Point< dim > > & get_points() const
void serialize(Archive &ar, const unsigned int version)
Quadrature(const unsigned int n_quadrature_points=0)
QAnisotropic(const Quadrature< 1 > &qx)
double weight(const unsigned int i) const
unsigned int size() const
std::vector< double > weights
Definition: quadrature.h:275
virtual ~Quadrature()
DeclException0(ExcInvalidQuadratureFormula)
std::size_t memory_consumption() const
void initialize(const std::vector< Point< dim > > &points, const std::vector< double > &weights)
QIterated(const Quadrature< 1 > &base_quadrature, const unsigned int n_copies)
std::vector< Point< dim > > quadrature_points
Definition: quadrature.h:267
const Point< dim > & point(const unsigned int i) const