// $Id$
// Version: $Name$
//
-// Copyright (C) 2006, 2007 by the deal.II authors
+// Copyright (C) 2006, 2007, 2008 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
data->update_flags = data->update_once | data->update_each;
const UpdateFlags flags(data->update_flags);
- const unsigned int n_q_points = quadrature.n_quadrature_points;
+ const unsigned int n_q_points = quadrature.size();
// some scratch arrays
std::vector<double> values(0);
for (unsigned int k=0; k<this->dofs_per_cell; ++k)
{
if (flags & update_values)
- for (unsigned int i=0; i<quadrature.n_quadrature_points; ++i)
+ for (unsigned int i=0; i<quadrature.size(); ++i)
data.shape_values(k,i) = fe_data.shape_values[k][i];
if (flags & update_gradients)
cell->face_orientation(face),
cell->face_flip(face),
cell->face_rotation(face),
- quadrature.n_quadrature_points);
+ quadrature.size());
const UpdateFlags flags(fe_data.update_once | fe_data.update_each);
for (unsigned int k=0; k<this->dofs_per_cell; ++k)
{
if (flags & update_values)
- for (unsigned int i=0; i<quadrature.n_quadrature_points; ++i)
+ for (unsigned int i=0; i<quadrature.size(); ++i)
data.shape_values(k,i) = fe_data.shape_values[k][i+offset];
if (flags & update_gradients)
cell->face_orientation(face),
cell->face_flip(face),
cell->face_rotation(face),
- quadrature.n_quadrature_points);
+ quadrature.size());
const UpdateFlags flags(fe_data.update_once | fe_data.update_each);
for (unsigned int k=0; k<this->dofs_per_cell; ++k)
{
if (flags & update_values)
- for (unsigned int i=0; i<quadrature.n_quadrature_points; ++i)
+ for (unsigned int i=0; i<quadrature.size(); ++i)
data.shape_values(k,i) = fe_data.shape_values[k][i+offset];
if (flags & update_gradients)
// $Id$
// Version: $Name$
//
-// Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007 by the deal.II authors
+// Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
* What this function does is the
* following: assume that there is scalar
* data <tt>u<sub>q</sub>, 0 <= q <
- * Q:=quadrature.n_quadrature_points</tt>
+ * Q:=quadrature.size()</tt>
* defined at the quadrature points of a
* cell, with the points defined by the
* given <tt>rhs_quadrature</tt>
// $Id$
// Version: $Name: $
//
-// Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
* ++cell)
* {
* values.reinit(cell);
- * for (unsigned int q=0; q<quadrature.n_quadrature_points; ++q)
+ * for (unsigned int q=0; q<quadrature.size(); ++q)
* for (unsigned int i=0; i<finite_element.dofs_per_cell; ++i)
* for (unsigned int j=0; j<finite_element.dofs_per_cell; ++j)
* A(i,j) += fe_values.shape_value(i,q) *
// $Id$
// Version: $Name$
//
-// Copyright (C) 2005, 2006 by the deal.II authors
+// Copyright (C) 2005, 2006, 2007, 2008 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
unsigned int m = 0;
for (unsigned int i=0; i<quadratures.size(); ++i)
- if (quadratures[i]->n_quadrature_points > m)
- m = quadratures[i]->n_quadrature_points;
+ if (quadratures[i]->size() > m)
+ m = quadratures[i]->size();
return m;
}
// $Id$
// Version: $Name: $
//
-// Copyright (C) 2005, 2006, 2007 by the deal.II authors
+// Copyright (C) 2005, 2006, 2007, 2008 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
| update_values));
typename DoFHandler<dim>::active_cell_iterator c;
- std::vector<Vector<double> > values(quadrature.n_quadrature_points,
+ std::vector<Vector<double> > values(quadrature.size(),
Vector<double> (dof.get_fe().n_components()));
double mean = 0.;
{
fe.reinit (c);
fe.get_function_values(v, values);
- for (unsigned int k=0; k< quadrature.n_quadrature_points; ++k)
+ for (unsigned int k=0; k< quadrature.size(); ++k)
{
mean += fe.JxW(k) * values[k](component);
area += fe.JxW(k);
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
// number of evaluation points)
// FEValues objects with slightly
// shifted positions
- std::vector<Point<dim> > diff_points (quadrature.n_quadrature_points);
+ std::vector<Point<dim> > diff_points (quadrature.size());
differences.resize(2*dim);
for (unsigned int d=0; d<dim; ++d)
// $Id$
// Version: $Name$
//
-// Copyright (C) 2003, 2004, 2005, 2006, 2007 by the deal.II authors
+// Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
QGauss<dim> cell_quadrature(deg+1);
const unsigned int n_interior_points
- = (deg>0) ? cell_quadrature.n_quadrature_points : 0;
+ = (deg>0) ? cell_quadrature.size() : 0;
this->generalized_support_points.resize (2 + n_interior_points);
interior_weights.reinit(TableIndices<3>(2+n_interior_points, 0, dim));
- for (unsigned int k=0;k<cell_quadrature.n_quadrature_points;++k)
+ for (unsigned int k=0;k<cell_quadrature.size();++k)
this->generalized_support_points[current++] = cell_quadrature.point(k);
Assert (current == this->generalized_support_points.size(),
FE_ABF<dim>::initialize_support_points (const unsigned int deg)
{
QGauss<dim> cell_quadrature(deg+2);
- const unsigned int n_interior_points = cell_quadrature.n_quadrature_points;
+ const unsigned int n_interior_points = cell_quadrature.size();
unsigned int n_face_points = (dim>1) ? 1 : 0;
// compute (deg+1)^(dim-1)
boundary_weights.reinit(n_face_points, legendre.n());
-// Assert (face_points.n_quadrature_points == this->dofs_per_face,
+// Assert (face_points.size() == this->dofs_per_face,
// ExcInternalError());
for (unsigned int k=0;k<n_face_points;++k)
// stem from applying the Gauss theorem to the nodal values, which
// was necessary to cast the ABF elements into the deal.II framework
// for vector valued elements.
- boundary_weights_abf.reinit(faces.n_quadrature_points, polynomials_abf[0]->n() * dim);
- for (unsigned int k=0;k < faces.n_quadrature_points;++k)
+ boundary_weights_abf.reinit(faces.size(), polynomials_abf[0]->n() * dim);
+ for (unsigned int k=0;k < faces.size();++k)
{
for (unsigned int i=0;i<polynomials_abf[0]->n() * dim;++i)
{
interior_weights.reinit(TableIndices<3>(n_interior_points, polynomials[0]->n(), dim));
- for (unsigned int k=0;k<cell_quadrature.n_quadrature_points;++k)
+ for (unsigned int k=0;k<cell_quadrature.size();++k)
{
for (unsigned int i=0;i<polynomials[0]->n();++i)
for (unsigned int d=0;d<dim;++d)
// Decouple the creation of the generalized support points
// from computation of interior weights.
- for (unsigned int k=0;k<cell_quadrature.n_quadrature_points;++k)
+ for (unsigned int k=0;k<cell_quadrature.size();++k)
this->generalized_support_points[current++] = cell_quadrature.point(k);
// Additional functionality for the ABF elements
// TODO: Here the canonical extension of the principle
// behind the ABF elements is implemented. It is unclear,
// if this really leads to the ABF spaces in 3D!
- interior_weights_abf.reinit(TableIndices<3>(cell_quadrature.n_quadrature_points,
+ interior_weights_abf.reinit(TableIndices<3>(cell_quadrature.size(),
polynomials_abf[0]->n() * dim, dim));
Tensor<1, dim> poly_grad;
- for (unsigned int k=0;k<cell_quadrature.n_quadrature_points;++k)
+ for (unsigned int k=0;k<cell_quadrature.size();++k)
{
for (unsigned int i=0;i<polynomials_abf[0]->n() * dim;++i)
{
FE_ABF<dim>::initialize_restriction()
{
QGauss<dim-1> q_base (rt_order+1);
- const unsigned int n_face_points = q_base.n_quadrature_points;
+ const unsigned int n_face_points = q_base.size();
// First, compute interpolation on
// subfaces
for (unsigned int face=0;face<GeometryInfo<dim>::faces_per_cell;++face)
// Store shape values, since the
// evaluation suffers if not
// ordered by point
- Table<2,double> cached_values(this->dofs_per_cell, q_face.n_quadrature_points);
- for (unsigned int k=0;k<q_face.n_quadrature_points;++k)
+ Table<2,double> cached_values(this->dofs_per_cell, q_face.size());
+ for (unsigned int k=0;k<q_face.size();++k)
for (unsigned int i = 0; i < this->dofs_per_cell; ++i)
cached_values(i,k)
= this->shape_value_component(i, q_face.point(k),
// Store shape values, since the
// evaluation suffers if not
// ordered by point
- Table<3,double> cached_values(this->dofs_per_cell, q_cell.n_quadrature_points, dim);
- for (unsigned int k=0;k<q_cell.n_quadrature_points;++k)
+ Table<3,double> cached_values(this->dofs_per_cell, q_cell.size(), dim);
+ for (unsigned int k=0;k<q_cell.size();++k)
for (unsigned int i = 0; i < this->dofs_per_cell; ++i)
for (unsigned int d=0;d<dim;++d)
cached_values(i,k,d) = this->shape_value_component(i, q_cell.point(k), d);
{
Quadrature<dim> q_sub = QProjector<dim>::project_to_child(q_cell, child);
- for (unsigned int k=0;k<q_sub.n_quadrature_points;++k)
+ for (unsigned int k=0;k<q_sub.size();++k)
for (unsigned int i_child = 0; i_child < this->dofs_per_cell; ++i_child)
for (unsigned int d=0;d<dim;++d)
for (unsigned int i_weight=0;i_weight<polynomials[d]->n();++i_weight)
// $Id$
// Version: $Name$
//
-// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007 by the deal.II authors
+// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
:
FE_Poly<TensorProductPolynomials<dim>, dim> (
TensorProductPolynomials<dim>(Polynomials::Lagrange::generate_complete_basis(points.get_points())),
- FiniteElementData<dim>(get_dpo_vector(points.n_quadrature_points-1), 1, points.n_quadrature_points-1, FiniteElementData<dim>::L2),
- std::vector<bool>(FiniteElementData<dim>(get_dpo_vector(points.n_quadrature_points-1),1, points.n_quadrature_points-1).dofs_per_cell, true),
+ FiniteElementData<dim>(get_dpo_vector(points.size()-1), 1, points.size()-1, FiniteElementData<dim>::L2),
+ std::vector<bool>(FiniteElementData<dim>(get_dpo_vector(points.size()-1),1, points.size()-1).dofs_per_cell, true),
std::vector<std::vector<bool> >(FiniteElementData<dim>(
- get_dpo_vector(points.n_quadrature_points-1),1, points.n_quadrature_points-1).dofs_per_cell, std::vector<bool>(1,true)))
+ get_dpo_vector(points.size()-1),1, points.size()-1).dofs_per_cell, std::vector<bool>(1,true)))
{
for (unsigned int i=0; i<GeometryInfo<dim>::children_per_cell; ++i)
this->prolongation[i].reinit (this->dofs_per_cell,
// $Id$
// Version: $Name$
//
-// Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007 by the deal.II authors
+// Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
data->update_flags = data->update_once | data->update_each;
const UpdateFlags flags(data->update_flags);
- const unsigned int n_q_points = quadrature.n_quadrature_points;
+ const unsigned int n_q_points = quadrature.size();
// initialize fields only if really
// necessary. otherwise, don't
// fields that have to be filled
const UpdateFlags flags(fe_data.current_update_flags());
- const unsigned int n_q_points = quadrature.n_quadrature_points;
+ const unsigned int n_q_points = quadrature.size();
// fill shape function
// values. these are vector-valued,
cell->face_orientation(face),
cell->face_flip(face),
cell->face_rotation(face),
- quadrature.n_quadrature_points));
+ quadrature.size()));
// get the flags indicating the
// fields that have to be filled
const UpdateFlags flags(fe_data.current_update_flags());
- const unsigned int n_q_points = quadrature.n_quadrature_points;
+ const unsigned int n_q_points = quadrature.size();
// fill shape function
// values. these are vector-valued,
cell->face_orientation(face),
cell->face_flip(face),
cell->face_rotation(face),
- quadrature.n_quadrature_points));
+ quadrature.size()));
// get the flags indicating the
// fields that have to be filled
const UpdateFlags flags(fe_data.current_update_flags());
- const unsigned int n_q_points = quadrature.n_quadrature_points;
+ const unsigned int n_q_points = quadrature.size();
// fill shape function
// values. these are vector-valued,
// $Id$
// Version: $Name$
//
-// Copyright (C) 2005, 2006, 2007 by the deal.II authors
+// Copyright (C) 2005, 2006, 2007, 2008 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
data->update_flags = data->update_once | data->update_each;
const UpdateFlags flags(data->update_flags);
- const unsigned int n_q_points = quadrature.n_quadrature_points;
+ const unsigned int n_q_points = quadrature.size();
// some scratch arrays
std::vector<Tensor<1,dim> > values(0);
// && dynamic_cast<const MappingCartesian<dim>*>(&mapping) != 0),
// ExcNotImplemented());
- const unsigned int n_q_points = quadrature.n_quadrature_points;
+ const unsigned int n_q_points = quadrature.size();
const UpdateFlags flags(fe_data.current_update_flags());
Assert(!(flags & update_values) || fe_data.shape_values.size() == this->dofs_per_cell,
// possible
InternalData &fe_data = dynamic_cast<InternalData &> (fedata);
- const unsigned int n_q_points = quadrature.n_quadrature_points;
+ const unsigned int n_q_points = quadrature.size();
// offset determines which data set
// to take (all data sets for all
// faces are stored contiguously)
// possible
InternalData &fe_data = dynamic_cast<InternalData &> (fedata);
- const unsigned int n_q_points = quadrature.n_quadrature_points;
+ const unsigned int n_q_points = quadrature.size();
// offset determines which data set
// to take (all data sets for all
// sub-faces are stored contiguously)
// $Id$
// Version: $Name$
//
-// Copyright (C) 2003, 2004, 2005, 2006, 2007 by the deal.II authors
+// Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
QGauss<dim> cell_quadrature(deg+1);
const unsigned int n_interior_points
- = (deg>0) ? cell_quadrature.n_quadrature_points : 0;
+ = (deg>0) ? cell_quadrature.size() : 0;
this->generalized_support_points.resize (2 + n_interior_points);
interior_weights.reinit(TableIndices<3>(2+n_interior_points, 0, dim));
- for (unsigned int k=0;k<cell_quadrature.n_quadrature_points;++k)
+ for (unsigned int k=0;k<cell_quadrature.size();++k)
this->generalized_support_points[current++] = cell_quadrature.point(k);
Assert (current == this->generalized_support_points.size(),
{
QGauss<dim> cell_quadrature(deg+1);
const unsigned int n_interior_points
- = (deg>0) ? cell_quadrature.n_quadrature_points : 0;
+ = (deg>0) ? cell_quadrature.size() : 0;
unsigned int n_face_points = (dim>1) ? 1 : 0;
// compute (deg+1)^(dim-1)
boundary_weights.reinit(n_face_points, legendre.n());
-// Assert (face_points.n_quadrature_points == this->dofs_per_face,
+// Assert (face_points.size() == this->dofs_per_face,
// ExcInternalError());
for (unsigned int k=0;k<n_face_points;++k)
interior_weights.reinit(TableIndices<3>(n_interior_points, polynomials[0]->n(), dim));
- for (unsigned int k=0;k<cell_quadrature.n_quadrature_points;++k)
+ for (unsigned int k=0;k<cell_quadrature.size();++k)
{
this->generalized_support_points[current++] = cell_quadrature.point(k);
for (unsigned int i=0;i<polynomials[0]->n();++i)
FE_RaviartThomas<dim>::initialize_restriction()
{
QGauss<dim-1> q_base (rt_order+1);
- const unsigned int n_face_points = q_base.n_quadrature_points;
+ const unsigned int n_face_points = q_base.size();
// First, compute interpolation on
// subfaces
for (unsigned int face=0;face<GeometryInfo<dim>::faces_per_cell;++face)
// Store shape values, since the
// evaluation suffers if not
// ordered by point
- Table<2,double> cached_values(this->dofs_per_cell, q_face.n_quadrature_points);
- for (unsigned int k=0;k<q_face.n_quadrature_points;++k)
+ Table<2,double> cached_values(this->dofs_per_cell, q_face.size());
+ for (unsigned int k=0;k<q_face.size();++k)
for (unsigned int i = 0; i < this->dofs_per_cell; ++i)
cached_values(i,k)
= this->shape_value_component(i, q_face.point(k),
// Store shape values, since the
// evaluation suffers if not
// ordered by point
- Table<3,double> cached_values(this->dofs_per_cell, q_cell.n_quadrature_points, dim);
- for (unsigned int k=0;k<q_cell.n_quadrature_points;++k)
+ Table<3,double> cached_values(this->dofs_per_cell, q_cell.size(), dim);
+ for (unsigned int k=0;k<q_cell.size();++k)
for (unsigned int i = 0; i < this->dofs_per_cell; ++i)
for (unsigned int d=0;d<dim;++d)
cached_values(i,k,d) = this->shape_value_component(i, q_cell.point(k), d);
{
Quadrature<dim> q_sub = QProjector<dim>::project_to_child(q_cell, child);
- for (unsigned int k=0;k<q_sub.n_quadrature_points;++k)
+ for (unsigned int k=0;k<q_sub.size();++k)
for (unsigned int i_child = 0; i_child < this->dofs_per_cell; ++i_child)
for (unsigned int d=0;d<dim;++d)
for (unsigned int i_weight=0;i_weight<polynomials[d]->n();++i_weight)
// $Id$
// Version: $Name$
//
-// Copyright (C) 2003, 2004, 2005, 2006, 2007 by the deal.II authors
+// Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
if (dim>1)
{
QGauss<dim-1> face_points (deg+1);
- Assert (face_points.n_quadrature_points == this->dofs_per_face,
+ Assert (face_points.size() == this->dofs_per_face,
ExcInternalError());
for (unsigned int k=0;k<this->dofs_per_face;++k)
this->generalized_face_support_points[k] = face_points.point(k);
((d==2) ? low : high));
Assert(dim<=3, ExcNotImplemented());
- for (unsigned int k=0;k<quadrature->n_quadrature_points;++k)
+ for (unsigned int k=0;k<quadrature->size();++k)
this->generalized_support_points[current++] = quadrature->point(k);
delete quadrature;
}
// $Id$
// Version: $Name$
//
-// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007 by the deal.II authors
+// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
typename Mapping<dim>::InternalDataBase &fedata,
FEValuesData<dim> &data) const
{
- const unsigned int n_q_points = quadrature.n_quadrature_points;
+ const unsigned int n_q_points = quadrature.size();
// convert data object to internal
// data for this class. fails with
// $Id$
// Version: $Name$
//
-// Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007 by the deal.II authors
+// Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
// This happens in the target space
FullMatrix<double> mass (n2, n2);
- for (unsigned int k=0;k<quadrature.n_quadrature_points;++k)
+ for (unsigned int k=0;k<quadrature.size();++k)
{
const double w = val2.JxW(k);
for (unsigned int i=0;i<n2;++i)
{
b = 0.;
for (unsigned int i=0;i<n2;++i)
- for (unsigned int k=0;k<quadrature.n_quadrature_points;++k)
+ for (unsigned int k=0;k<quadrature.size();++k)
{
const double w = val2.JxW(k);
const double u = val1.shape_value(j,k);
MappingCartesian<dim> mapping;
QGauss<dim> q_fine(degree+1);
- const unsigned int nq = q_fine.n_quadrature_points;
+ const unsigned int nq = q_fine.size();
FEValues<dim> fine (mapping, fe, q_fine,
update_quadrature_points | update_JxW_values | update_values);
QGauss<dim-1> q_gauss(degree+1);
const Quadrature<dim> q_fine = QProjector<dim>::project_to_face(q_gauss, face_fine);
- const unsigned int nq = q_fine.n_quadrature_points;
+ const unsigned int nq = q_fine.size();
// In order to make the loops below
// simpler, we introduce vectors
MappingCartesian<dim> mapping;
QGauss<dim> q_fine(degree+1);
- const unsigned int nq = q_fine.n_quadrature_points;
+ const unsigned int nq = q_fine.size();
FEValues<dim> coarse (mapping, fe, q_fine,
update_quadrature_points | update_JxW_values | update_values);
// first build the matrices M and Q
// described in the documentation
FullMatrix<double> M (fe.dofs_per_cell, fe.dofs_per_cell);
- FullMatrix<double> Q (fe.dofs_per_cell, rhs_quadrature.n_quadrature_points);
+ FullMatrix<double> Q (fe.dofs_per_cell, rhs_quadrature.size());
for (unsigned int i=0; i<fe.dofs_per_cell; ++i)
for (unsigned int j=0; j<fe.dofs_per_cell; ++j)
- for (unsigned int q=0; q<lhs_quadrature.n_quadrature_points; ++q)
+ for (unsigned int q=0; q<lhs_quadrature.size(); ++q)
M(i,j) += fe.shape_value (i, lhs_quadrature.point(q)) *
fe.shape_value (j, lhs_quadrature.point(q)) *
lhs_quadrature.weight(q);
for (unsigned int i=0; i<fe.dofs_per_cell; ++i)
- for (unsigned int q=0; q<rhs_quadrature.n_quadrature_points; ++q)
+ for (unsigned int q=0; q<rhs_quadrature.size(); ++q)
Q(i,q) += fe.shape_value (i, rhs_quadrature.point(q)) *
rhs_quadrature.weight(q);
M_inverse.invert (M);
// finally compute the result
- X.reinit (fe.dofs_per_cell, rhs_quadrature.n_quadrature_points);
+ X.reinit (fe.dofs_per_cell, rhs_quadrature.size());
M_inverse.mmult (X, Q);
Assert (X.m() == fe.dofs_per_cell, ExcInternalError());
- Assert (X.n() == rhs_quadrature.n_quadrature_points, ExcInternalError());
+ Assert (X.n() == rhs_quadrature.size(), ExcInternalError());
}
FullMatrix<double> &I_q)
{
Assert (fe.n_components() == 1, ExcNotImplemented());
- Assert (I_q.m() == quadrature.n_quadrature_points,
+ Assert (I_q.m() == quadrature.size(),
ExcMessage ("Wrong matrix size"));
Assert (I_q.n() == fe.dofs_per_cell, ExcMessage ("Wrong matrix size"));
- for (unsigned int q=0; q<quadrature.n_quadrature_points; ++q)
+ for (unsigned int q=0; q<quadrature.size(); ++q)
for (unsigned int i=0; i<fe.dofs_per_cell; ++i)
I_q(q,i) = fe.shape_value (i, quadrature.point(q));
}
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
const Quadrature<dim> &q,
const UpdateFlags update_flags)
:
- FEValuesBase<dim> (q.n_quadrature_points,
+ FEValuesBase<dim> (q.size(),
fe.dofs_per_cell,
update_default,
mapping,
const Quadrature<dim> &q,
const UpdateFlags update_flags)
:
- FEValuesBase<dim> (q.n_quadrature_points,
+ FEValuesBase<dim> (q.size(),
fe.dofs_per_cell,
update_default,
StaticMappingQ1<dim>::mapping,
const Quadrature<dim-1> &quadrature,
const UpdateFlags update_flags)
:
- FEFaceValuesBase<dim> (quadrature.n_quadrature_points,
+ FEFaceValuesBase<dim> (quadrature.size(),
fe.dofs_per_cell,
update_flags,
mapping,
const Quadrature<dim-1> &quadrature,
const UpdateFlags update_flags)
:
- FEFaceValuesBase<dim> (quadrature.n_quadrature_points,
+ FEFaceValuesBase<dim> (quadrature.size(),
fe.dofs_per_cell,
update_flags,
StaticMappingQ1<dim>::mapping,
const Quadrature<dim-1> &quadrature,
const UpdateFlags update_flags)
:
- FEFaceValuesBase<dim> (quadrature.n_quadrature_points,
+ FEFaceValuesBase<dim> (quadrature.size(),
fe.dofs_per_cell,
update_flags,
mapping,
const Quadrature<dim-1> &quadrature,
const UpdateFlags update_flags)
:
- FEFaceValuesBase<dim> (quadrature.n_quadrature_points,
+ FEFaceValuesBase<dim> (quadrature.size(),
fe.dofs_per_cell,
update_flags,
StaticMappingQ1<dim>::mapping,
// $Id$
// Version: $Name$
//
-// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007 by the deal.II authors
+// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
{
InternalData *data = new InternalData(n_shape_functions);
this->compute_data (update_flags, quadrature,
- quadrature.n_quadrature_points, *data);
+ quadrature.size(), *data);
if (!use_mapping_q_on_all_cells)
this->compute_data (update_flags, quadrature,
- quadrature.n_quadrature_points, data->mapping_q1_data);
+ quadrature.size(), data->mapping_q1_data);
return data;
}
InternalData *data = new InternalData(n_shape_functions);
const Quadrature<dim> q (QProjector<dim>::project_to_all_faces(quadrature));
this->compute_face_data (update_flags, q,
- quadrature.n_quadrature_points, *data);
+ quadrature.size(), *data);
if (!use_mapping_q_on_all_cells)
this->compute_face_data (update_flags, q,
- quadrature.n_quadrature_points,
+ quadrature.size(),
data->mapping_q1_data);
return data;
}
InternalData *data = new InternalData(n_shape_functions);
const Quadrature<dim> q (QProjector<dim>::project_to_all_subfaces(quadrature));
this->compute_face_data (update_flags, q,
- quadrature.n_quadrature_points, *data);
+ quadrature.size(), *data);
if (!use_mapping_q_on_all_cells)
this->compute_face_data (update_flags, q,
- quadrature.n_quadrature_points,
+ quadrature.size(),
data->mapping_q1_data);
return data;
}
else
p_data=&data;
- const unsigned int n_q_points=q.n_quadrature_points;
+ const unsigned int n_q_points=q.size();
this->compute_fill_face (cell, face_no, false,
n_q_points,
QProjector<dim>::DataSetDescriptor::
else
p_data=&data;
- const unsigned int n_q_points=q.n_quadrature_points;
+ const unsigned int n_q_points=q.size();
this->compute_fill_face (cell, face_no, true,
n_q_points,
QProjector<dim>::DataSetDescriptor::
// gradients at the quadrature
// points on the unit cell
const QGauss<dim> quadrature(degree+1);
- const unsigned int n_q_points=quadrature.n_quadrature_points;
+ const unsigned int n_q_points=quadrature.size();
InternalData quadrature_data(n_shape_functions);
quadrature_data.shape_derivatives.resize(n_shape_functions * n_q_points);
// $Id$
// Version: $Name$
//
-// Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007 by the deal.II authors
+// Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
const unsigned int n_original_q_points,
InternalData &data) const
{
- const unsigned int n_q_points = q.n_quadrature_points;
+ const unsigned int n_q_points = q.size();
data.update_once = update_once(update_flags);
data.update_each = update_each(update_flags);
const Quadrature<dim>& q) const
{
InternalData* data = new InternalData(n_shape_functions);
- compute_data (update_flags, q, q.n_quadrature_points, *data);
+ compute_data (update_flags, q, q.size(), *data);
return data;
}
InternalData* data = new InternalData(n_shape_functions);
compute_face_data (update_flags,
QProjector<dim>::project_to_all_faces(quadrature),
- quadrature.n_quadrature_points,
+ quadrature.size(),
*data);
return data;
InternalData* data = new InternalData(n_shape_functions);
compute_face_data (update_flags,
QProjector<dim>::project_to_all_subfaces(quadrature),
- quadrature.n_quadrature_points,
+ quadrature.size(),
*data);
return data;
Assert(data_ptr!=0, ExcInternalError());
InternalData &data=*data_ptr;
- const unsigned int n_q_points=q.n_quadrature_points;
+ const unsigned int n_q_points=q.size();
compute_fill (cell, n_q_points, DataSetDescriptor::cell (),
data, quadrature_points);
Assert(data_ptr!=0, ExcInternalError());
InternalData &data=*data_ptr;
- const unsigned int n_q_points = q.n_quadrature_points;
+ const unsigned int n_q_points = q.size();
compute_fill_face (cell, face_no, false,
n_q_points,
Assert(data_ptr!=0, ExcInternalError());
InternalData &data=*data_ptr;
- const unsigned int n_q_points = q.n_quadrature_points;
+ const unsigned int n_q_points = q.size();
compute_fill_face (cell, face_no, true,
n_q_points,