lac \
fe \
deal.II \
+ integrators \
multigrid \
bits \
hp \
- aniso \
- codim_one \
- serialization \
+ aniso \
+ codim_one \
+ serialization \
$(if $(DEAL_II_USE_MPI:no=), $(if $(USE_CONTRIB_P4EST:no=),mpi,),) \
$(if $(USE_CONTRIB_P4EST:no=), distributed_grids,) \
$(if $(USE_CONTRIB_PETSC:no=), petsc,) \
// $Id$
// Version: $Name$
//
-// Copyright (C) 2003, 2004, 2005, 2007, 2008 by the deal.II authors
+// Copyright (C) 2003, 2004, 2005, 2007, 2008, 2010 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
fe_face_values1.reinit (neighbor_child, neighbor_neighbor);
fe_face_values2.reinit (cell, face_no, subface_no);
- for (unsigned int q=0; q<quadrature.n_quadrature_points; ++q)
+ for (unsigned int q=0; q<quadrature.size(); ++q)
{
Assert ((fe_face_values1.quadrature_point(q)-
fe_face_values2.quadrature_point(q)).square()
// $Id$
// Version: $Name$
//
-// Copyright (C) 2007 by the deal.II authors
+// Copyright (C) 2007, 2010 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 direction,
const double order)
{
- std::vector<double> derivatives(quadrature.n_quadrature_points);
- std::vector<double> differences(quadrature.n_quadrature_points);
+ std::vector<double> derivatives(quadrature.size());
+ std::vector<double> differences(quadrature.size());
// Compute derivatives with one
// step size and store errors
const unsigned int direction,
const double order)
{
- std::vector<Tensor<1,dim> > derivatives(quadrature.n_quadrature_points);
- std::vector<Tensor<1,dim> > differences(quadrature.n_quadrature_points);
+ std::vector<Tensor<1,dim> > derivatives(quadrature.size());
+ std::vector<Tensor<1,dim> > differences(quadrature.size());
const double h = (order < 3) ? 1.e-2 : 1.e-1 ;
// Compute derivatives with one
Functions::FourierSineFunction<dim> f(wave_vector);
- std::vector<double> values(quadrature.n_quadrature_points);
- std::vector<Tensor<1,dim> > gradients(quadrature.n_quadrature_points);
+ std::vector<double> values(quadrature.size());
+ std::vector<Tensor<1,dim> > gradients(quadrature.size());
f.value_list(quadrature.get_points(), values);
f.gradient_list(quadrature.get_points(), gradients);
quadrature_int=0;
// Check the polynomial x^i*y^i
- for (unsigned int x=0; x<quadrature.n_quadrature_points; ++x)
+ for (unsigned int x=0; x<quadrature.size(); ++x)
{
double f=1.;
switch (dim)
// check the ordering of
// the quadrature points
bool in_order=true;
- for (unsigned int x=1; x<quadrature.n_quadrature_points; ++x)
+ for (unsigned int x=1; x<quadrature.size(); ++x)
{
if (points[x](0)<=points[x-1](0))
in_order=false;
}
if (!in_order)
- for (unsigned int x=0; x<quadrature.n_quadrature_points; ++x)
+ for (unsigned int x=0; x<quadrature.size(); ++x)
deallog << points[x] << std::endl;
}
}
// Check the polynomial
// x^i*y^i*z^i
- for (unsigned int x=0; x<quadrature.n_quadrature_points; ++x)
+ for (unsigned int x=0; x<quadrature.size(); ++x)
{
long double f=1.;
switch (dim)
deallog << "QGaussLobatto(" << n << ")" << std::endl;
QGaussLobatto<1> q(n);
- for (unsigned int i=0; i<q.n_quadrature_points; ++i)
+ for (unsigned int i=0; i<q.size(); ++i)
deallog << q.point(i) << ' ' << q.weight(i) << std::endl;
// the points must be
// symmetrically located around
// 0.5
double p = 0;
- for (unsigned int i=0; i<q.n_quadrature_points; ++i)
+ for (unsigned int i=0; i<q.size(); ++i)
p += (q.point(i)[0] - 0.5);
Assert (std::fabs(p) < 1e-12, ExcInternalError());
// the sum of weights must be
// one
double w = 0;
- for (unsigned int i=0; i<q.n_quadrature_points; ++i)
+ for (unsigned int i=0; i<q.size(); ++i)
w += q.weight(i);
Assert (std::fabs(w-1) < 1e-12, ExcInternalError());
}
{
DataOutBase::Patch<dim, dim> patch;
patch.n_subdivisions = n_sub;
- for (unsigned int k=0;k<trapez.n_quadrature_points;++k)
+ for (unsigned int k=0;k<trapez.size();++k)
{
Point<dim> p = trapez.point(k);
if (dim>=1) p(0) += i1;
// $Id$
// Version: $Name$
//
-// Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2008 by the deal.II authors
+// Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2008, 2010 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
QGauss<1> gauss(degree);
double sum = 0.;
- for (unsigned int i=0;i<gauss.n_quadrature_points;++i)
+ for (unsigned int i=0;i<gauss.size();++i)
{
double x = gauss.point(i)(0);
double P1 = p1.value(x);
void
check_poly (const Quadrature<1>& q)
{
- deallog << "Points: " << q.n_quadrature_points << std::endl;
+ deallog << "Points: " << q.size() << std::endl;
std::vector<Polynomial<double> > p = generate_complete_Lagrange_basis(q.get_points());
check_interpolation(p, q.get_points());
}
std::vector<Tensor<3,dim> > grads2;
- for (unsigned int k=0;k<quadrature.n_quadrature_points;++k)
+ for (unsigned int k=0;k<quadrature.size();++k)
{
if (k%(poly.degree()+4) == 0)
deallog << "BDM" << poly.degree() << '<' << dim << '>' << std::endl;
std::vector<Tensor<3,dim> > grads2;
- for (unsigned int k=0;k<quadrature.n_quadrature_points;++k)
+ for (unsigned int k=0;k<quadrature.size();++k)
{
if (k%(poly.degree()+4) == 0)
deallog << "RT" << poly.degree() << '<' << dim << '>' << std::endl;
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2008, 2009 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2008, 2009, 2010 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
Quadrature<dim> q = QProjector<dim>::project_to_line(quadrature, p1, p2);
double s = 0.;
- for (unsigned int k=0;k<q.n_quadrature_points;++k)
+ for (unsigned int k=0;k<q.size();++k)
{
deallog << k << '\t' << q.point(k) << std::endl;
s += q.weight(k);
void check_face(Quadrature<1>& q1)
{
deallog << "Checking dim " << dim
- << " 1d-points " << q1.n_quadrature_points
+ << " 1d-points " << q1.size()
<< std::endl;
Quadrature<dim-1> subquadrature(q1);
Quadrature<dim> quadrature
= QProjector<dim>::project_to_face(subquadrature, f);
- for (unsigned int k=0;k<quadrature.n_quadrature_points;++k)
+ for (unsigned int k=0;k<quadrature.size();++k)
deallog << quadrature.point(k) << std::endl;
}
Quadrature<dim> quadrature
= QProjector<dim>::project_to_face(subquadrature, f);
- for (unsigned int k=0;k<quadrature.n_quadrature_points;++k)
+ for (unsigned int k=0;k<quadrature.size();++k)
deallog << quadrature.point(k) << std::endl;
}
}
template<int dim>
void check_faces (Quadrature<1>& q1)
{
- const unsigned int nq = q1.n_quadrature_points;
+ const unsigned int nq = q1.size();
deallog << "Checking dim " << dim
<< " 1d-points " << nq
Quadrature<dim-1> subquadrature(q1);
- const unsigned int nqs = subquadrature.n_quadrature_points;
+ const unsigned int nqs = subquadrature.size();
Quadrature<dim> faces = QProjector<dim>::project_to_all_faces(subquadrature);
// $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, 2010 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
quadrature_int=0;
// Check the polynomial x^i*y^i
- for (unsigned int x=0; x<quadrature.n_quadrature_points; ++x)
+ for (unsigned int x=0; x<quadrature.size(); ++x)
{
double f=1.;
switch (dim)
// check the ordering of
// the quadrature points
bool in_order=true;
- for (unsigned int x=1; x<quadrature.n_quadrature_points; ++x)
+ for (unsigned int x=1; x<quadrature.size(); ++x)
{
if (points[x](0)<=points[x-1](0))
in_order=false;
}
if (!in_order)
- for (unsigned int x=0; x<quadrature.n_quadrature_points; ++x)
+ for (unsigned int x=0; x<quadrature.size(); ++x)
deallog << points[x] << std::endl;
}
}
// Check the polynomial
// x^i*y^i*z^i
- for (unsigned int x=0; x<quadrature.n_quadrature_points; ++x)
+ for (unsigned int x=0; x<quadrature.size(); ++x)
{
long double f=1.;
switch (dim)
// $Id$
// Version: $Name$
//
-// Copyright (C) 2005 by the deal.II authors
+// Copyright (C) 2005, 2010 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> q_rhs(fe.degree+1>2 ? fe.degree+1-2 : 1);
FullMatrix<double> X (fe.dofs_per_cell,
- q_rhs.n_quadrature_points);
+ q_rhs.size());
FETools::compute_projection_from_quadrature_points_matrix (fe,
q_lhs, q_rhs,
// $Id$
// Version: $Name$
//
-// Copyright (C) 2005 by the deal.II authors
+// Copyright (C) 2005, 2010 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
// at least as many degrees of freedom in
// the finite element as there are
// quadrature points
- if (fe.dofs_per_cell < q_rhs.n_quadrature_points)
+ if (fe.dofs_per_cell < q_rhs.size())
return;
deallog << "dofs_per_cell=" << fe.dofs_per_cell
- << ", n_q_points=" << q_rhs.n_quadrature_points
+ << ", n_q_points=" << q_rhs.size()
<< std::endl;
FullMatrix<double> X (fe.dofs_per_cell,
- q_rhs.n_quadrature_points);
+ q_rhs.size());
FETools::compute_projection_from_quadrature_points_matrix (fe,
q_lhs, q_rhs,
// then compute the matrix that
// interpolates back to the quadrature
// points
- FullMatrix<double> I_q (q_rhs.n_quadrature_points, fe.dofs_per_cell);
+ FullMatrix<double> I_q (q_rhs.size(), fe.dofs_per_cell);
FETools::compute_interpolation_to_quadrature_points_matrix (fe, q_rhs,
I_q);
- FullMatrix<double> product (q_rhs.n_quadrature_points,
- q_rhs.n_quadrature_points);
+ FullMatrix<double> product (q_rhs.size(),
+ q_rhs.size());
I_q.mmult (product, X);
// the product should be the identity
// $Id$
// Version: $Name$
//
-// Copyright (C) 2005 by the deal.II authors
+// Copyright (C) 2005, 2010 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> q_rhs(fe.degree+3);
FullMatrix<double> X (fe.dofs_per_cell,
- q_rhs.n_quadrature_points);
+ q_rhs.size());
FETools::compute_projection_from_quadrature_points_matrix (fe,
q_lhs, q_rhs,
// $Id$
// Version: $Name$
//
-// Copyright (C) 2005 by the deal.II authors
+// Copyright (C) 2005, 2010 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
1./fe.dofs_per_cell));
FullMatrix<double> X (fe.dofs_per_cell,
- q_rhs.n_quadrature_points);
+ q_rhs.size());
Assert (X.m() == X.n(), ExcInternalError());
// joa_1.cc,v 1.3 2003/06/09 16:00:38 wolf Exp
// Version:
//
-// Copyright (C) 2003, 2004, 2005, 2007 by the deal.II authors
+// Copyright (C) 2003, 2004, 2005, 2007, 2010 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
update_q_points | update_JxW_values);
const unsigned int dofs_per_cell = fe.dofs_per_cell;
- const unsigned int n_q_points = quadrature_formula.n_quadrature_points;
+ const unsigned int n_q_points = quadrature_formula.size();
FullMatrix<double> cell_matrix (dofs_per_cell, dofs_per_cell);
Vector<double> cell_rhs (dofs_per_cell);
// $Id$
// Version: $Name$
//
-// Copyright (C) 2003, 2004, 2005 by the deal.II authors
+// Copyright (C) 2003, 2004, 2005, 2010 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
fe_face_values1.reinit (neighbor_child, neighbor_neighbor);
fe_face_values2.reinit (cell, face_no, subface_no);
- for (unsigned int q=0; q<quadrature.n_quadrature_points; ++q)
+ for (unsigned int q=0; q<quadrature.size(); ++q)
{
Assert ((fe_face_values1.quadrature_point(q)-
fe_face_values2.quadrature_point(q)).square()
for (unsigned int f=0; f<GeometryInfo<3>::faces_per_cell; ++f)
{
fe_face_values.reinit (cell, f);
- for (unsigned int q=0; q<q_face.n_quadrature_points; ++q)
+ for (unsigned int q=0; q<q_face.size(); ++q)
n1 += fe_face_values.normal_vector(q) *
fe_face_values.JxW(q);
}
for (unsigned int sf=0; sf<GeometryInfo<3>::max_children_per_face; ++sf)
{
fe_subface_values.reinit (cell, f, sf);
- for (unsigned int q=0; q<q_face.n_quadrature_points; ++q)
+ for (unsigned int q=0; q<q_face.size(); ++q)
n2 += fe_subface_values.normal_vector(q) *
fe_subface_values.JxW(q);
}
// $Id$
// Version: $Name$
//
-// Copyright (C) 2003, 2004, 2005 by the deal.II authors
+// Copyright (C) 2003, 2004, 2005, 2010 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
fe_face_values1.reinit (cell, f);
fe_face_values2.reinit (cell->neighbor(f), nn);
- for (unsigned int q=0; q<quadrature.n_quadrature_points; ++q)
+ for (unsigned int q=0; q<quadrature.size(); ++q)
{
// in order to reduce
// output file size,
// $Id$
// Version: $Name$
//
-// Copyright (C) 2003, 2004, 2005 by the deal.II authors
+// Copyright (C) 2003, 2004, 2005, 2010 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
deallog << "Cell " << cell << ", face " << f
<< std::endl;
- for (unsigned int q=0; q<quadrature.n_quadrature_points; ++q)
+ for (unsigned int q=0; q<quadrature.size(); ++q)
{
// in order to reduce
// output file size,
// $Id$
// Version: $Name$
//
-// Copyright (C) 2003, 2004, 2005 by the deal.II authors
+// Copyright (C) 2003, 2004, 2005, 2010 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
for (unsigned int f=0; f<GeometryInfo<dim>::faces_per_cell; ++f)
{
fe_face_values.reinit (cell, f);
- for (unsigned int q=0; q<q_face.n_quadrature_points; ++q)
+ for (unsigned int q=0; q<q_face.size(); ++q)
n1 += fe_face_values.normal_vector(q) *
fe_face_values.JxW(q);
}
for (unsigned int sf=0; sf<GeometryInfo<dim>::max_children_per_face; ++sf)
{
fe_subface_values.reinit (cell, f, sf);
- for (unsigned int q=0; q<q_face.n_quadrature_points; ++q)
+ for (unsigned int q=0; q<q_face.size(); ++q)
n2 += fe_subface_values.normal_vector(q) *
fe_subface_values.JxW(q);
}
// $Id$
// Version: $Name$
//
-// Copyright (C) 2003, 2004, 2005 by the deal.II authors
+// Copyright (C) 2003, 2004, 2005, 2010 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
for (unsigned int f=0; f<GeometryInfo<dim>::faces_per_cell; ++f)
{
fe_face_values.reinit (cell, f);
- for (unsigned int q=0; q<q_face.n_quadrature_points; ++q)
+ for (unsigned int q=0; q<q_face.size(); ++q)
n1 += fe_face_values.normal_vector(q) *
fe_face_values.JxW(q);
}
for (unsigned int sf=0; sf<GeometryInfo<dim>::max_children_per_face; ++sf)
{
fe_subface_values.reinit (cell, f, sf);
- for (unsigned int q=0; q<q_face.n_quadrature_points; ++q)
+ for (unsigned int q=0; q<q_face.size(); ++q)
n2 += fe_subface_values.normal_vector(q) *
fe_subface_values.JxW(q);
}
// $Id$
// Version: $Name$
//
-// Copyright (C) 2003, 2004, 2005 by the deal.II authors
+// Copyright (C) 2003, 2004, 2005, 2010 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
for (unsigned int f=0; f<GeometryInfo<dim>::faces_per_cell; ++f)
{
fe_face_values.reinit (cell, f);
- for (unsigned int q=0; q<q_face.n_quadrature_points; ++q)
+ for (unsigned int q=0; q<q_face.size(); ++q)
n1 += fe_face_values.normal_vector(q) *
fe_face_values.JxW(q);
}
for (unsigned int sf=0; sf<GeometryInfo<dim>::max_children_per_face; ++sf)
{
fe_subface_values.reinit (cell, f, sf);
- for (unsigned int q=0; q<q_face.n_quadrature_points; ++q)
+ for (unsigned int q=0; q<q_face.size(); ++q)
n2 += fe_subface_values.normal_vector(q) *
fe_subface_values.JxW(q);
}
// $Id$
// Version: $Name$
//
-// Copyright (C) 2003, 2004, 2005 by the deal.II authors
+// Copyright (C) 2003, 2004, 2005, 2010 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
for (unsigned int f=0; f<GeometryInfo<dim>::faces_per_cell; ++f)
{
fe_face_values.reinit (cell, f);
- for (unsigned int q=0; q<q_face.n_quadrature_points; ++q)
+ for (unsigned int q=0; q<q_face.size(); ++q)
n1 += fe_face_values.normal_vector(q) *
fe_face_values.JxW(q);
}
for (unsigned int sf=0; sf<GeometryInfo<dim>::max_children_per_face; ++sf)
{
fe_subface_values.reinit (cell, f, sf);
- for (unsigned int q=0; q<q_face.n_quadrature_points; ++q)
+ for (unsigned int q=0; q<q_face.size(); ++q)
n2 += fe_subface_values.normal_vector(q) *
fe_subface_values.JxW(q);
}
// $Id$
// Version: $Name$
//
-// Copyright (C) 2003, 2004, 2005 by the deal.II authors
+// Copyright (C) 2003, 2004, 2005, 2010 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
if (cell->at_boundary(f))
{
fe_face_values.reinit (cell, f);
- for (unsigned int q=0; q<q_face.n_quadrature_points; ++q)
+ for (unsigned int q=0; q<q_face.size(); ++q)
n1 += fe_face_values.quadrature_point(q) *
fe_face_values.JxW(q);
}
for (unsigned int sf=0; sf<GeometryInfo<dim>::max_children_per_face; ++sf)
{
fe_subface_values.reinit (cell, f, sf);
- for (unsigned int q=0; q<q_face.n_quadrature_points; ++q)
+ for (unsigned int q=0; q<q_face.size(); ++q)
n2 += fe_subface_values.quadrature_point(q) *
fe_subface_values.JxW(q);
}
// $Id$
// Version: $Name$
//
-// Copyright (C) 2003, 2004, 2005 by the deal.II authors
+// Copyright (C) 2003, 2004, 2005, 2010 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
if (cell->at_boundary(f))
{
fe_face_values.reinit (cell, f);
- for (unsigned int q=0; q<q_face.n_quadrature_points; ++q)
+ for (unsigned int q=0; q<q_face.size(); ++q)
n1 += fe_face_values.quadrature_point(q) *
fe_face_values.JxW(q);
}
for (unsigned int sf=0; sf<GeometryInfo<dim>::max_children_per_face; ++sf)
{
fe_subface_values.reinit (cell, f, sf);
- for (unsigned int q=0; q<q_face.n_quadrature_points; ++q)
+ for (unsigned int q=0; q<q_face.size(); ++q)
n2 += fe_subface_values.quadrature_point(q) *
fe_subface_values.JxW(q);
}
// $Id$
// Version: $Name$
//
-// Copyright (C) 2003, 2004, 2005 by the deal.II authors
+// Copyright (C) 2003, 2004, 2005, 2010 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
if (cell->at_boundary(f))
{
fe_face_values.reinit (cell, f);
- for (unsigned int q=0; q<q_face.n_quadrature_points; ++q)
+ for (unsigned int q=0; q<q_face.size(); ++q)
n1 += fe_face_values.quadrature_point(q) *
fe_face_values.JxW(q);
}
for (unsigned int sf=0; sf<GeometryInfo<dim>::max_children_per_face; ++sf)
{
fe_subface_values.reinit (cell, f, sf);
- for (unsigned int q=0; q<q_face.n_quadrature_points; ++q)
+ for (unsigned int q=0; q<q_face.size(); ++q)
n2 += fe_subface_values.quadrature_point(q) *
fe_subface_values.JxW(q);
}
// $Id$
// Version: $Name$
//
-// Copyright (C) 2003, 2004, 2005 by the deal.II authors
+// Copyright (C) 2003, 2004, 2005, 2010 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
if (cell->at_boundary(f))
{
fe_face_values.reinit (cell, f);
- for (unsigned int q=0; q<q_face.n_quadrature_points; ++q)
+ for (unsigned int q=0; q<q_face.size(); ++q)
n1 += fe_face_values.quadrature_point(q) *
fe_face_values.JxW(q);
}
for (unsigned int sf=0; sf<GeometryInfo<dim>::max_children_per_face; ++sf)
{
fe_subface_values.reinit (cell, f, sf);
- for (unsigned int q=0; q<q_face.n_quadrature_points; ++q)
+ for (unsigned int q=0; q<q_face.size(); ++q)
n2 += fe_subface_values.quadrature_point(q) *
fe_subface_values.JxW(q);
}
deallog << "Cell " << cell << ", face " << f
<< std::endl;
- for (unsigned int q=0; q<quadrature.n_quadrature_points; ++q)
+ for (unsigned int q=0; q<quadrature.size(); ++q)
{
deallog << " " << fe_face_values1.quadrature_point(q)
<< std::endl;
// $Id$
// Version: $Name$
//
-// Copyright (C) 2005, 2006 by the deal.II authors and Oliver Kayser-Herold
+// Copyright (C) 2005, 2006, 2010 by the deal.II authors and Oliver Kayser-Herold
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
update_normal_vectors |
update_JxW_values));
- const unsigned int n_q_face = quad.n_quadrature_points;
+ const unsigned int n_q_face = quad.size();
const unsigned int n_components = dof_handler.get_fe().n_components();
// Cell iterators
// $Id$
// Version: $Name$
//
-// Copyright (C) 2005, 2006, 2007, 2008 by the deal.II authors
+// Copyright (C) 2005, 2006, 2007, 2008, 2010 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
update_gradients | update_JxW_values);
const unsigned int dofs_per_cell = fe->dofs_per_cell;
- const unsigned int n_q_points = quadrature->n_quadrature_points;
+ const unsigned int n_q_points = quadrature->size();
FullMatrix<double> cell_matrix (dofs_per_cell, dofs_per_cell);
update_JxW_values);
const unsigned int dofs_per_cell = this->fe->dofs_per_cell;
- const unsigned int n_q_points = this->quadrature->n_quadrature_points;
+ const unsigned int n_q_points = this->quadrature->size();
Vector<double> cell_rhs (dofs_per_cell);
std::vector<double> rhs_values (n_q_points);
// $Id$
// Version: $Name$
//
-// Copyright (C) 2005, 2006, 2007, 2008, 2009 by the deal.II authors
+// Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
vertex_quadrature,
update_gradients | update_q_points);
std::vector<Tensor<1,dim> >
- solution_gradients (vertex_quadrature.n_quadrature_points);
+ solution_gradients (vertex_quadrature.size());
typename DoFHandler<dim>::active_cell_iterator
cell = dof_handler.begin_active(),
update_gradients | update_JxW_values);
const unsigned int dofs_per_cell = fe->dofs_per_cell;
- const unsigned int n_q_points = quadrature->n_quadrature_points;
+ const unsigned int n_q_points = quadrature->size();
FullMatrix<double> cell_matrix (dofs_per_cell, dofs_per_cell);
update_JxW_values);
const unsigned int dofs_per_cell = this->fe->dofs_per_cell;
- const unsigned int n_q_points = this->quadrature->n_quadrature_points;
+ const unsigned int n_q_points = this->quadrature->size();
Vector<double> cell_rhs (dofs_per_cell);
std::vector<double> rhs_values (n_q_points);
right_hand_side (&right_hand_side)
{
const unsigned int n_q_points
- = quadrature.n_quadrature_points;
+ = quadrature.size();
cell_residual.resize(n_q_points);
rhs_values.resize(n_q_points);
update_gradients)
{
const unsigned int n_face_q_points
- = face_quadrature.n_quadrature_points;
+ = face_quadrature.size();
jump_residual.resize(n_face_q_points);
dual_weights.resize(n_face_q_points);
// $Id$
// Version: $Name$
//
-// Copyright (C) 2005, 2006, 2007, 2008 by the deal.II authors
+// Copyright (C) 2005, 2006, 2007, 2008, 2010 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
update_q_points | update_JxW_values);
const unsigned int dofs_per_cell = fe.dofs_per_cell;
- const unsigned int n_q_points = quadrature_formula.n_quadrature_points;
+ const unsigned int n_q_points = quadrature_formula.size();
FullMatrix<double> cell_matrix (dofs_per_cell, dofs_per_cell);
Vector<double> cell_rhs (dofs_per_cell);
FEValues<dim> neighbor_fe_values (fe, quadrature,
update_gradients);
- std::vector<double> local_values (quadrature.n_quadrature_points);
- std::vector<Tensor<1,dim> > local_gradients (quadrature.n_quadrature_points);
- std::vector<Tensor<2,dim> > local_2nd_derivs (quadrature.n_quadrature_points);
+ std::vector<double> local_values (quadrature.size());
+ std::vector<Tensor<1,dim> > local_gradients (quadrature.size());
+ std::vector<Tensor<2,dim> > local_2nd_derivs (quadrature.size());
DoFHandler<dim>::active_cell_iterator
cell = dof_handler.begin_active (),
fe_values.get_function_2nd_derivatives (present_solution, local_2nd_derivs);
double cell_residual_norm = 0;
- for (unsigned int q=0; q<quadrature.n_quadrature_points; ++q)
+ for (unsigned int q=0; q<quadrature.size(); ++q)
{
const double x = fe_values.quadrature_point(q)[0];
const double u = local_values[q];
update_values | update_gradients |
update_q_points | update_JxW_values);
- const unsigned int n_q_points = quadrature_formula.n_quadrature_points;
+ const unsigned int n_q_points = quadrature_formula.size();
std::vector<double> local_solution_values (n_q_points);
std::vector<Tensor<1,dim> > local_solution_grads (n_q_points);
// $Id$
// Version: $Name$
//
-// Copyright (C) 2005, 2006, 2008 by the deal.II authors
+// Copyright (C) 2005, 2006, 2008, 2010 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
update_q_points | update_JxW_values);
const unsigned int dofs_per_cell = fe.dofs_per_cell;
- const unsigned int n_q_points = quadrature_formula.n_quadrature_points;
+ const unsigned int n_q_points = quadrature_formula.size();
FullMatrix<double> cell_matrix (dofs_per_cell, dofs_per_cell);
Vector<double> cell_rhs (dofs_per_cell);
update_q_points | update_JxW_values);
const unsigned int dofs_per_cell = fe.dofs_per_cell;
- const unsigned int n_q_points = quadrature_formula.n_quadrature_points;
+ const unsigned int n_q_points = quadrature_formula.size();
FullMatrix<double> cell_matrix (dofs_per_cell, dofs_per_cell);
// $Id$
// Version: $Name$
//
-// Copyright (C) 2005, 2006, 2008 by the deal.II authors
+// Copyright (C) 2005, 2006, 2008, 2010 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 | update_gradients | update_JxW_values);
const unsigned int dofs_per_cell = fe.dofs_per_cell;
- const unsigned int n_q_points = quadrature_formula.n_quadrature_points;
+ const unsigned int n_q_points = quadrature_formula.size();
FullMatrix<double> cell_matrix (dofs_per_cell, dofs_per_cell);
Vector<double> cell_rhs (dofs_per_cell);
// $Id$
// Version: $Name$
//
-// Copyright (C) 2005, 2006, 2007, 2008 by the deal.II authors
+// Copyright (C) 2005, 2006, 2007, 2008, 2010 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
update_q_points | update_JxW_values);
const unsigned int dofs_per_cell = fe.dofs_per_cell;
- const unsigned int n_q_points = quadrature_formula.n_quadrature_points;
+ const unsigned int n_q_points = quadrature_formula.size();
FullMatrix<double> cell_matrix (dofs_per_cell, dofs_per_cell);
Vector<double> cell_rhs (dofs_per_cell);
// $Id$
// Version: $Name$
//
-// Copyright (C) 2005, 2006, 2007, 2008 by the deal.II authors
+// Copyright (C) 2005, 2006, 2007, 2008, 2010 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
update_q_points | update_JxW_values);
const unsigned int dofs_per_cell = fe.dofs_per_cell;
- const unsigned int n_q_points = quadrature_formula.n_quadrature_points;
+ const unsigned int n_q_points = quadrature_formula.size();
FullMatrix<double> cell_matrix (dofs_per_cell, dofs_per_cell);
Vector<double> cell_rhs (dofs_per_cell);
// $Id$
// Version: $Name$
//
-// Copyright (C) 2005, 2006, 2007, 2008 by the deal.II authors
+// Copyright (C) 2005, 2006, 2007, 2008, 2010 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
update_q_points | update_JxW_values);
const unsigned int dofs_per_cell = fe.dofs_per_cell;
- const unsigned int n_q_points = quadrature_formula.n_quadrature_points;
+ const unsigned int n_q_points = quadrature_formula.size();
FullMatrix<double> cell_matrix (dofs_per_cell, dofs_per_cell);
Vector<double> cell_rhs (dofs_per_cell);
// $Id$
// Version: $Name$
//
-// Copyright (C) 2005, 2006, 2007, 2008 by the deal.II authors
+// Copyright (C) 2005, 2006, 2007, 2008, 2010 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> quadrature_formula (3);
QGauss<dim-1> face_quadrature_formula (3);
- const unsigned int n_q_points = quadrature_formula.n_quadrature_points;
- const unsigned int n_face_q_points = face_quadrature_formula.n_quadrature_points;
+ const unsigned int n_q_points = quadrature_formula.size();
+ const unsigned int n_face_q_points = face_quadrature_formula.size();
const unsigned int dofs_per_cell = (*fe).dofs_per_cell;
// $Id$
// Version: $Name$
//
-// Copyright (C) 2005, 2006, 2008 by the deal.II authors
+// Copyright (C) 2005, 2006, 2008, 2010 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
update_q_points | update_JxW_values);
const unsigned int dofs_per_cell = fe.dofs_per_cell;
- const unsigned int n_q_points = quadrature_formula.n_quadrature_points;
+ const unsigned int n_q_points = quadrature_formula.size();
FullMatrix<double> cell_matrix (dofs_per_cell, dofs_per_cell);
Vector<double> cell_rhs (dofs_per_cell);
// $Id$
// Version: $Name$
//
-// Copyright (C) 2003, 2004, 2005 by the deal.II authors
+// Copyright (C) 2003, 2004, 2005, 2010 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
if (cell->at_boundary(f))
{
fe_face_values.reinit (cell, f);
- for (unsigned int q=0; q<q_face.n_quadrature_points; ++q)
+ for (unsigned int q=0; q<q_face.size(); ++q)
v1 += (fe_face_values.normal_vector(q) *
fe_face_values.quadrature_point(q)) *
fe_face_values.JxW(q);
for (unsigned int sf=0; sf<GeometryInfo<dim>::max_children_per_face; ++sf)
{
fe_subface_values.reinit (cell, f, sf);
- for (unsigned int q=0; q<q_face.n_quadrature_points; ++q)
+ for (unsigned int q=0; q<q_face.size(); ++q)
v2 += (fe_subface_values.normal_vector(q) *
fe_subface_values.quadrature_point(q)) *
fe_subface_values.JxW(q);
// $Id$
// Version: $Name$
//
-// Copyright (C) 2003, 2004, 2005 by the deal.II authors
+// Copyright (C) 2003, 2004, 2005, 2010 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
if (cell->at_boundary(f))
{
fe_face_values.reinit (cell, f);
- for (unsigned int q=0; q<q_face.n_quadrature_points; ++q)
+ for (unsigned int q=0; q<q_face.size(); ++q)
v1 += (fe_face_values.normal_vector(q) *
fe_face_values.quadrature_point(q)) *
fe_face_values.JxW(q);
for (unsigned int sf=0; sf<GeometryInfo<dim>::max_children_per_face; ++sf)
{
fe_subface_values.reinit (cell, f, sf);
- for (unsigned int q=0; q<q_face.n_quadrature_points; ++q)
+ for (unsigned int q=0; q<q_face.size(); ++q)
v2 += (fe_subface_values.normal_vector(q) *
fe_subface_values.quadrature_point(q)) *
fe_subface_values.JxW(q);
// $Id$
// Version: $Name$
//
-// Copyright (C) 2003, 2004, 2005 by the deal.II authors
+// Copyright (C) 2003, 2004, 2005, 2010 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
if (cell->at_boundary(f))
{
fe_face_values.reinit (cell, f);
- for (unsigned int q=0; q<q_face.n_quadrature_points; ++q)
+ for (unsigned int q=0; q<q_face.size(); ++q)
v1 += (fe_face_values.normal_vector(q) *
fe_face_values.quadrature_point(q)) *
fe_face_values.JxW(q);
for (unsigned int sf=0; sf<GeometryInfo<dim>::max_children_per_face; ++sf)
{
fe_subface_values.reinit (cell, f, sf);
- for (unsigned int q=0; q<q_face.n_quadrature_points; ++q)
+ for (unsigned int q=0; q<q_face.size(); ++q)
v2 += (fe_subface_values.normal_vector(q) *
fe_subface_values.quadrature_point(q)) *
fe_subface_values.JxW(q);
// $Id$
// Version: $Name$
//
-// Copyright (C) 2003, 2004, 2005 by the deal.II authors
+// Copyright (C) 2003, 2004, 2005, 2010 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
if (cell->at_boundary(f))
{
fe_face_values.reinit (cell, f);
- for (unsigned int q=0; q<q_face.n_quadrature_points; ++q)
+ for (unsigned int q=0; q<q_face.size(); ++q)
v1 += (fe_face_values.normal_vector(q) *
fe_face_values.quadrature_point(q)) *
fe_face_values.JxW(q);
for (unsigned int sf=0; sf<GeometryInfo<dim>::max_children_per_face; ++sf)
{
fe_subface_values.reinit (cell, f, sf);
- for (unsigned int q=0; q<q_face.n_quadrature_points; ++q)
+ for (unsigned int q=0; q<q_face.size(); ++q)
v2 += (fe_subface_values.normal_vector(q) *
fe_subface_values.quadrature_point(q)) *
fe_subface_values.JxW(q);
// $Id$
// Version: $Name$
//
-// Copyright (C) 2005, 2008 by the deal.II authors
+// Copyright (C) 2005, 2008, 2010 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
update_gradients |
update_cell_normal_vectors );
- std::vector< Point<spacedim> > cell_normals(q_iterated.n_quadrature_points);
- std::vector< Point<spacedim> > cell_tangentials(q_iterated.n_quadrature_points);
+ std::vector< Point<spacedim> > cell_normals(q_iterated.size());
+ std::vector< Point<spacedim> > cell_tangentials(q_iterated.size());
std::vector<unsigned int> local_dof_indices (fe_q.dofs_per_cell);
typename DoFHandler<spacedim-1, spacedim>::active_cell_iterator
cell_normals = fe_values_q.get_cell_normal_vectors();
- for(unsigned int i=0; i<q_iterated.n_quadrature_points; ++i)
+ for(unsigned int i=0; i<q_iterated.size(); ++i)
{
cell_tangentials[i][0] = cell_normals[i][1];
cell_tangentials[i][1] = -cell_normals[i][0];
// factor (smooth_solution..) is taken
// so that it is the coefficient of
// the fun_th shape function of the cell.
- std::vector< Tensor<1,spacedim> > gradient(q_iterated.n_quadrature_points);
- for(unsigned int pnt=0; pnt<q_iterated.n_quadrature_points; ++pnt)
+ std::vector< Tensor<1,spacedim> > gradient(q_iterated.size());
+ for(unsigned int pnt=0; pnt<q_iterated.size(); ++pnt)
for(unsigned int fun=0; fun<fe_q.dofs_per_cell; ++fun)
{
gradient[pnt]+=
// std::cout
// << "gradienti "<<std::endl;
-// for(unsigned int pnt=0; pnt<q_iterated.n_quadrature_points; ++pnt)
+// for(unsigned int pnt=0; pnt<q_iterated.size(); ++pnt)
// std::cout
// << pnt << " - "
// << gradient[pnt]
// << std::endl;
- for(unsigned int pnt=0; pnt<q_iterated.n_quadrature_points; ++pnt)
+ for(unsigned int pnt=0; pnt<q_iterated.size(); ++pnt)
{
tangential_derivative(cell->index())=
contract(
}
-// // for(unsigned int pnt=0; pnt<q_iterated.n_quadrature_points; ++pnt)
+// // for(unsigned int pnt=0; pnt<q_iterated.size(); ++pnt)
// std::cout
// // << pnt <<" - "
// << tangential_derivative(cell->index())
// $Id$
// Version: $Name$
//
-// Copyright (C) 2005, 2008, 2009 by the deal.II authors
+// Copyright (C) 2005, 2008, 2009, 2010 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
FullMatrix<double> cell_matrix (dofs_per_cell, dofs_per_cell);
- std::vector< Point<spacedim> > cell_normals(q_midpoint.n_quadrature_points);
- std::vector< Point<spacedim> > cell_tangentials(q_midpoint.n_quadrature_points);
+ std::vector< Point<spacedim> > cell_normals(q_midpoint.size());
+ std::vector< Point<spacedim> > cell_tangentials(q_midpoint.size());
std::vector<double> shape_directional_derivative(dofs_per_cell);
Vector<double> projected_directional_derivative(triangulation.n_cells());
// $Id$
// Version: $Name$
//
-// Copyright (C) 2005 by the deal.II authors
+// Copyright (C) 2005, 2010 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
for(;cell!=endc;++cell)
{
deallog<<cell<< std::endl;
- for(unsigned int q=0; q<quad.n_quadrature_points; ++q)
+ for(unsigned int q=0; q<quad.size(); ++q)
{
real = mapping.transform_unit_to_real_cell(cell, quad.point(q));
// unit = mapping.transform_real_to_unit_cell(cell, real);
// $Id$
// Version: $Name$
//
-// Copyright (C) 2005, 2009 by the deal.II authors
+// Copyright (C) 2005, 2009, 2010 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
for(;cell!=endc;++cell)
{
deallog<<cell<< std::endl;
- for(unsigned int q=0; q<quad.n_quadrature_points; ++q)
+ for(unsigned int q=0; q<quad.size(); ++q)
{
real = mapping.transform_unit_to_real_cell(cell, quad.point(q));
// unit = mapping.transform_real_to_unit_cell(cell, real);
update_JxW_values));
const unsigned int dofs_per_cell = fe.dofs_per_cell;
- const unsigned int n_q_points = quadrature_formula.n_quadrature_points;
+ const unsigned int n_q_points = quadrature_formula.size();
FullMatrix<double> cell_matrix (dofs_per_cell, dofs_per_cell);
::Vector<double> cell_rhs (dofs_per_cell);
| update_q_points | update_JxW_values);
std::vector <unsigned int> global_dofs (element.dofs_per_cell);
- std::vector <double> function (quadrature.n_quadrature_points);
+ std::vector <double> function (quadrature.size());
Vector<double> u (dof.n_dofs ());
Vector<double> f (dof.n_dofs ());
cell->get_dof_indices (global_dofs);
cosine.value_list (fe.get_quadrature_points(), function);
- for (unsigned int k=0;k<quadrature.n_quadrature_points;++k)
+ for (unsigned int k=0;k<quadrature.size();++k)
{
double dx = fe.JxW (k);
double h1 = 0.;
double h2 = 0.;
- std::vector<double> u_local (quadrature.n_quadrature_points);
- std::vector<Tensor<1,dim> > Du (quadrature.n_quadrature_points);
- std::vector<Tensor<1,dim> > Df (quadrature.n_quadrature_points);
- std::vector<Tensor<2,dim> > DDu (quadrature.n_quadrature_points);
- std::vector<Tensor<2,dim> > DDf (quadrature.n_quadrature_points);
+ std::vector<double> u_local (quadrature.size());
+ std::vector<Tensor<1,dim> > Du (quadrature.size());
+ std::vector<Tensor<1,dim> > Df (quadrature.size());
+ std::vector<Tensor<2,dim> > DDu (quadrature.size());
+ std::vector<Tensor<2,dim> > DDf (quadrature.size());
for (cell = dof.begin_active(); cell != end;++cell)
{
fe2.get_function_grads (u, Du);
fe2.get_function_2nd_derivatives (u,DDu);
- for (unsigned int k=0;k<quadrature.n_quadrature_points;++k)
+ for (unsigned int k=0;k<quadrature.size();++k)
{
const double dx = fe.JxW (k);
double e = u_local[k];
// $Id$
// Version: $Name$
//
-// Copyright (C) 2007, 2008 by the deal.II authors
+// Copyright (C) 2007, 2008, 2010 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 | update_gradients | update_hessians);
fe_values.reinit (dof.begin_active());
- std::vector<double> scalar_values (quadrature.n_quadrature_points);
- std::vector<Vector<double> > vector_values (quadrature.n_quadrature_points,
+ std::vector<double> scalar_values (quadrature.size());
+ std::vector<Vector<double> > vector_values (quadrature.size(),
Vector<double>(fe.n_components()));
fe_values.get_function_values (fe_function, vector_values);
// $Id$
// Version: $Name$
//
-// Copyright (C) 2007, 2008 by the deal.II authors
+// Copyright (C) 2007, 2008, 2010 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 | update_gradients | update_hessians);
fe_values.reinit (dof.begin_active());
- std::vector<Tensor<1,dim> > scalar_values (quadrature.n_quadrature_points);
+ std::vector<Tensor<1,dim> > scalar_values (quadrature.size());
std::vector<std::vector<Tensor<1,dim> > >
- vector_values (quadrature.n_quadrature_points,
+ vector_values (quadrature.size(),
std::vector<Tensor<1,dim> >(fe.n_components()));
fe_values.get_function_gradients (fe_function, vector_values);
// $Id$
// Version: $Name$
//
-// Copyright (C) 2007, 2008 by the deal.II authors
+// Copyright (C) 2007, 2008, 2010 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 | update_gradients | update_hessians);
fe_values.reinit (dof.begin_active());
- std::vector<Tensor<2,dim> > scalar_values (quadrature.n_quadrature_points);
+ std::vector<Tensor<2,dim> > scalar_values (quadrature.size());
std::vector<std::vector<Tensor<2,dim> > >
- vector_values (quadrature.n_quadrature_points,
+ vector_values (quadrature.size(),
std::vector<Tensor<2,dim> >(fe.n_components()));
fe_values.get_function_hessians (fe_function, vector_values);
update_values | update_gradients | update_hessians);
fe_values.reinit (dof.begin_active());
- std::vector<double> scalar_values (quadrature.n_quadrature_points);
- std::vector<Vector<double> > vector_values (quadrature.n_quadrature_points,
+ std::vector<double> scalar_values (quadrature.size());
+ std::vector<Vector<double> > vector_values (quadrature.size(),
Vector<double>(fe.n_components()));
fe_values.get_function_values (fe_function, vector_values);
update_values | update_gradients | update_hessians);
fe_values.reinit (dof.begin_active());
- std::vector<Tensor<1,dim> > scalar_values (quadrature.n_quadrature_points);
+ std::vector<Tensor<1,dim> > scalar_values (quadrature.size());
std::vector<std::vector<Tensor<1,dim> > >
- vector_values (quadrature.n_quadrature_points,
+ vector_values (quadrature.size(),
std::vector<Tensor<1,dim> >(fe.n_components()));
fe_values.get_function_gradients (fe_function, vector_values);
update_values | update_gradients | update_hessians);
fe_values.reinit (dof.begin_active());
- std::vector<Tensor<2,dim> > scalar_values (quadrature.n_quadrature_points);
+ std::vector<Tensor<2,dim> > scalar_values (quadrature.size());
std::vector<std::vector<Tensor<2,dim> > >
- vector_values (quadrature.n_quadrature_points,
+ vector_values (quadrature.size(),
std::vector<Tensor<2,dim> >(fe.n_components()));
fe_values.get_function_hessians (fe_function, vector_values);
update_values | update_gradients | update_hessians);
fe_values.reinit (dof.begin_active());
- std::vector<Tensor<2,dim> > scalar_values (quadrature.n_quadrature_points);
+ std::vector<Tensor<2,dim> > scalar_values (quadrature.size());
std::vector<std::vector<Tensor<2,dim> > >
- vector_values (quadrature.n_quadrature_points,
+ vector_values (quadrature.size(),
std::vector<Tensor<2,dim> >(fe.n_components()));
fe_values.get_function_hessians (fe_function, vector_values);
update_values | update_gradients | update_hessians);
fe_values.reinit (dof.begin_active());
- std::vector<Tensor<2,dim> > scalar_values (quadrature.n_quadrature_points);
+ std::vector<Tensor<2,dim> > scalar_values (quadrature.size());
std::vector<std::vector<Tensor<2,dim> > >
- vector_values (quadrature.n_quadrature_points,
+ vector_values (quadrature.size(),
std::vector<Tensor<2,dim> >(fe.n_components()));
fe_values.get_function_hessians (fe_function, vector_values);
update_values | update_gradients | update_hessians);
fe_values.reinit (dof.begin_active());
- std::vector<Tensor<2,dim> > scalar_values (quadrature.n_quadrature_points);
+ std::vector<Tensor<2,dim> > scalar_values (quadrature.size());
std::vector<std::vector<Tensor<2,dim> > >
- vector_values (quadrature.n_quadrature_points,
+ vector_values (quadrature.size(),
std::vector<Tensor<2,dim> >(fe.n_components()));
fe_values.get_function_hessians (fe_function, vector_values);
update_values | update_gradients | update_hessians);
fe_values.reinit (dof.begin_active());
- std::vector<double> scalar_values (quadrature.n_quadrature_points);
+ std::vector<double> scalar_values (quadrature.size());
std::vector<Vector<double> >
- vector_values (quadrature.n_quadrature_points,
+ vector_values (quadrature.size(),
Vector<double>(fe.n_components()));
fe_values.get_function_values (fe_function, vector_values);
// $Id$
// Version: $Name$
//
-// Copyright (C) 2007, 2008 by the deal.II authors
+// Copyright (C) 2007, 2008, 2010 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 | update_gradients | update_hessians);
fe_values.reinit (dof.begin_active());
- std::vector<Tensor<1,dim> > selected_vector_values (quadrature.n_quadrature_points);
- std::vector<Vector<double> > vector_values (quadrature.n_quadrature_points,
+ std::vector<Tensor<1,dim> > selected_vector_values (quadrature.size());
+ std::vector<Vector<double> > vector_values (quadrature.size(),
Vector<double>(fe.n_components()));
fe_values.get_function_values (fe_function, vector_values);
// $Id$
// Version: $Name$
//
-// Copyright (C) 2007, 2008 by the deal.II authors
+// Copyright (C) 2007, 2008, 2010 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 | update_gradients | update_hessians);
fe_values.reinit (dof.begin_active());
- std::vector<Tensor<2,dim> > selected_vector_values (quadrature.n_quadrature_points);
+ std::vector<Tensor<2,dim> > selected_vector_values (quadrature.size());
std::vector<std::vector<Tensor<1,dim> > >
- vector_values (quadrature.n_quadrature_points,
+ vector_values (quadrature.size(),
std::vector<Tensor<1,dim> >(fe.n_components()));
fe_values.get_function_gradients (fe_function, vector_values);
// $Id$
// Version: $Name$
//
-// Copyright (C) 2007, 2008 by the deal.II authors
+// Copyright (C) 2007, 2008, 2010 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 | update_gradients | update_hessians);
fe_values.reinit (dof.begin_active());
- std::vector<Tensor<3,dim> > selected_vector_values (quadrature.n_quadrature_points);
+ std::vector<Tensor<3,dim> > selected_vector_values (quadrature.size());
std::vector<std::vector<Tensor<2,dim> > >
- vector_values (quadrature.n_quadrature_points,
+ vector_values (quadrature.size(),
std::vector<Tensor<2,dim> >(fe.n_components()));
fe_values.get_function_hessians (fe_function, vector_values);
update_values | update_gradients | update_hessians);
fe_values.reinit (dof.begin_active());
- std::vector<Tensor<1,dim> > selected_vector_values (quadrature.n_quadrature_points);
- std::vector<Vector<double> > vector_values (quadrature.n_quadrature_points,
+ std::vector<Tensor<1,dim> > selected_vector_values (quadrature.size());
+ std::vector<Vector<double> > vector_values (quadrature.size(),
Vector<double>(fe.n_components()));
fe_values.get_function_values (fe_function, vector_values);
update_values | update_gradients | update_hessians);
fe_values.reinit (dof.begin_active());
- std::vector<Tensor<2,dim> > selected_vector_values (quadrature.n_quadrature_points);
+ std::vector<Tensor<2,dim> > selected_vector_values (quadrature.size());
std::vector<std::vector<Tensor<1,dim> > >
- vector_values (quadrature.n_quadrature_points,
+ vector_values (quadrature.size(),
std::vector<Tensor<1,dim> >(fe.n_components()));
fe_values.get_function_gradients (fe_function, vector_values);
update_values | update_gradients | update_hessians);
fe_values.reinit (dof.begin_active());
- std::vector<Tensor<3,dim> > selected_vector_values (quadrature.n_quadrature_points);
+ std::vector<Tensor<3,dim> > selected_vector_values (quadrature.size());
std::vector<std::vector<Tensor<2,dim> > >
- vector_values (quadrature.n_quadrature_points,
+ vector_values (quadrature.size(),
std::vector<Tensor<2,dim> >(fe.n_components()));
fe_values.get_function_hessians (fe_function, vector_values);
// $Id$
// Version: $Name$
//
-// Copyright (C) 2007, 2008 by the deal.II authors
+// Copyright (C) 2007, 2008, 2010 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 | update_gradients | update_hessians);
fe_values.reinit (dof.begin_active());
- std::vector<SymmetricTensor<2,dim> > selected_vector_values (quadrature.n_quadrature_points);
+ std::vector<SymmetricTensor<2,dim> > selected_vector_values (quadrature.size());
std::vector<std::vector<Tensor<1,dim> > >
- vector_values (quadrature.n_quadrature_points,
+ vector_values (quadrature.size(),
std::vector<Tensor<1,dim> >(fe.n_components()));
fe_values.get_function_gradients (fe_function, vector_values);
update_values | update_gradients | update_hessians);
fe_values.reinit (dof.begin_active());
- std::vector<SymmetricTensor<2,dim> > selected_vector_values (quadrature.n_quadrature_points);
+ std::vector<SymmetricTensor<2,dim> > selected_vector_values (quadrature.size());
std::vector<std::vector<Tensor<1,dim> > >
- vector_values (quadrature.n_quadrature_points,
+ vector_values (quadrature.size(),
std::vector<Tensor<1,dim> >(fe.n_components()));
fe_values.get_function_gradients (fe_function, vector_values);
// $Id$
// Version: $Name$
//
-// Copyright (C) 2007, 2008 by the deal.II authors
+// Copyright (C) 2007, 2008, 2010 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 | update_gradients | update_hessians);
fe_values.reinit (dof.begin_active());
- std::vector<double> selected_vector_values (quadrature.n_quadrature_points);
+ std::vector<double> selected_vector_values (quadrature.size());
std::vector<std::vector<Tensor<1,dim> > >
- vector_values (quadrature.n_quadrature_points,
+ vector_values (quadrature.size(),
std::vector<Tensor<1,dim> >(fe.n_components()));
fe_values.get_function_gradients (fe_function, vector_values);
update_values | update_gradients | update_hessians);
fe_values.reinit (dof.begin_active());
- std::vector<double> selected_vector_values (quadrature.n_quadrature_points);
+ std::vector<double> selected_vector_values (quadrature.size());
std::vector<std::vector<Tensor<1,dim> > >
- vector_values (quadrature.n_quadrature_points,
+ vector_values (quadrature.size(),
std::vector<Tensor<1,dim> >(fe.n_components()));
fe_values.get_function_gradients (fe_function, vector_values);
// $Id$
// Version: $Name$
//
-// Copyright (C) 2009 by Andrew McBride and the deal.II authors
+// Copyright (C) 2009, 2010 by Andrew McBride and 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 dofs_per_cell = fe.dofs_per_cell;
deallog << "dofs_per_cell: " << fe.dofs_per_cell << std::endl;
- const unsigned int n_q_points = quadrature_formula.size();
-
+
FullMatrix<double> local_matrix(dofs_per_cell, dofs_per_cell);
Vector<double> local_rhs(dofs_per_cell);
| update_q_points | update_JxW_values);
std::vector <unsigned int> global_dofs (element.dofs_per_cell);
- std::vector <double> function (quadrature.n_quadrature_points);
+ std::vector <double> function (quadrature.size());
Vector<double> f (dof.n_dofs ());
cell->get_dof_indices (global_dofs);
cosine.value_list (fe.get_quadrature_points(), function);
- for (unsigned int k=0;k<quadrature.n_quadrature_points;++k)
+ for (unsigned int k=0;k<quadrature.size();++k)
{
double dx = fe.JxW (k);
update_JxW_values|
update_contravariant_transformation));
- const unsigned int n_q_points = quad.n_quadrature_points;
+ const unsigned int n_q_points = quad.size();
const unsigned int n_components = dof_handler->get_fe().n_components();
// Cell iterators
QGauss<2> quad_temp(6);
sprintf (buf, "DoFs per Quad: %i per Line %i per Vert %i\n", fe.dofs_per_quad, fe.dofs_per_line, fe.dofs_per_vertex);
deallog << buf;
- sprintf (buf, "QPoints %i\n", quad_temp.n_quadrature_points);
+ sprintf (buf, "QPoints %i\n", quad_temp.size());
deallog << buf;
// Create an deformation object for the Eulerian mapping
// $Id$
// Version: $Name$
//
-// Copyright (C) 2006, 2007, 2008 by the deal.II authors
+// Copyright (C) 2006, 2007, 2008, 2010 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
for (unsigned int i=0; i<fe_collection[fe].dofs_per_cell; ++i)
{
std::complex<double> sum = 0;
- for (unsigned int q=0; q<quadrature.n_quadrature_points; ++q)
+ for (unsigned int q=0; q<quadrature.size(); ++q)
{
const Point<dim> x_q = quadrature.point(q);
sum += std::exp(std::complex<double>(0,1) *
// $Id$
// Version: $Name$
//
-// Copyright (C) 2005, 2006, 2007 by the deal.II authors
+// Copyright (C) 2005, 2006, 2007, 2010 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
vertex_quadrature,
update_gradients | update_q_points);
std::vector<Tensor<1,dim> >
- solution_gradients (vertex_quadrature.n_quadrature_points);
+ solution_gradients (vertex_quadrature.size());
typename hp::DoFHandler<dim>::active_cell_iterator
cell = dof_handler.begin_active(),
update_gradients | update_JxW_values);
const unsigned int dofs_per_cell = (*fe)[0].dofs_per_cell;
- const unsigned int n_q_points = (*quadrature)[0].n_quadrature_points;
+ const unsigned int n_q_points = (*quadrature)[0].size();
FullMatrix<double> cell_matrix (dofs_per_cell, dofs_per_cell);
update_JxW_values);
const unsigned int dofs_per_cell = (*this->fe)[0].dofs_per_cell;
- const unsigned int n_q_points = (*this->quadrature)[0].n_quadrature_points;
+ const unsigned int n_q_points = (*this->quadrature)[0].size();
Vector<double> cell_rhs (dofs_per_cell);
std::vector<double> rhs_values (n_q_points);
right_hand_side (&right_hand_side)
{
const unsigned int n_q_points
- = quadrature[0].n_quadrature_points;
+ = quadrature[0].size();
cell_residual.resize(n_q_points);
rhs_values.resize(n_q_points);
update_gradients)
{
const unsigned int n_face_q_points
- = face_quadrature[0].n_quadrature_points;
+ = face_quadrature[0].size();
jump_residual.resize(n_face_q_points);
dual_weights.resize(n_face_q_points);
// $Id$
// Version: $Name$
//
-// Copyright (C) 2005, 2006, 2007, 2008 by the deal.II authors
+// Copyright (C) 2005, 2006, 2007, 2008, 2010 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
update_q_points | update_JxW_values);
const unsigned int dofs_per_cell = fe[0].dofs_per_cell;
- const unsigned int n_q_points = quadrature_formula[0].n_quadrature_points;
+ const unsigned int n_q_points = quadrature_formula[0].size();
FullMatrix<double> cell_matrix (dofs_per_cell, dofs_per_cell);
Vector<double> cell_rhs (dofs_per_cell);
hp::FEValues<dim> neighbor_fe_values (fe, quadrature,
update_gradients);
- std::vector<double> local_values (quadrature[0].n_quadrature_points);
- std::vector<Tensor<1,dim> > local_gradients (quadrature[0].n_quadrature_points);
- std::vector<Tensor<2,dim> > local_2nd_derivs (quadrature[0].n_quadrature_points);
+ std::vector<double> local_values (quadrature[0].size());
+ std::vector<Tensor<1,dim> > local_gradients (quadrature[0].size());
+ std::vector<Tensor<2,dim> > local_2nd_derivs (quadrature[0].size());
hp::DoFHandler<dim>::active_cell_iterator
cell = dof_handler.begin_active (),
fe_values.get_present_fe_values().get_function_2nd_derivatives (present_solution, local_2nd_derivs);
double cell_residual_norm = 0;
- for (unsigned int q=0; q<quadrature[0].n_quadrature_points; ++q)
+ for (unsigned int q=0; q<quadrature[0].size(); ++q)
{
const double x = fe_values.get_present_fe_values().quadrature_point(q)[0];
const double u = local_values[q];
update_values | update_gradients |
update_q_points | update_JxW_values);
- const unsigned int n_q_points = quadrature_formula[0].n_quadrature_points;
+ const unsigned int n_q_points = quadrature_formula[0].size();
std::vector<double> local_solution_values (n_q_points);
std::vector<Tensor<1,dim> > local_solution_grads (n_q_points);
// rt_distorted_01.cc,v 1.3 2003/06/09 16:00:38 wolf Exp
// Version:
//
-// Copyright (C) 2003, 2005, 2006, 2007 by the deal.II authors
+// Copyright (C) 2003, 2005, 2006, 2007, 2010 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
update_q_points |
update_JxW_values));
- const unsigned int n_q_points = quad.n_quadrature_points;
+ const unsigned int n_q_points = quad.size();
const unsigned int n_components = dof_handler->get_fe().n_components();
// Cell iterators
update_JxW_values|
update_contravariant_transformation));
- const unsigned int n_q_points = quad.n_quadrature_points;
+ const unsigned int n_q_points = quad.size();
const unsigned int n_components = dof_handler.get_fe().n_components();
// Cell iterators
sprintf (buf,"DoFs per Quad: %i per Line %i per Vert %i\n", fe.dofs_per_quad, fe.dofs_per_line, fe.dofs_per_vertex);
deallog << buf;
- sprintf (buf,"QPoints %i\n", quad_temp.n_quadrature_points);
+ sprintf (buf,"QPoints %i\n", quad_temp.size());
deallog << buf;
// Create an deformation object for the Eulerian mapping
// abf_01.cc,v 1.3 2003/06/09 16:00:38 wolf Exp
// Version:
//
-// Copyright (C) 2003, 2005, 2006, 2008 by the deal.II authors
+// Copyright (C) 2003, 2005, 2006, 2008, 2010 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
update_gradients |
update_JxW_values));
- const unsigned int n_q_points = quad.n_quadrature_points;
+ const unsigned int n_q_points = quad.size();
const unsigned int n_components = dof_handler->get_fe().n_components();
const unsigned int dofs_per_cell = dof_handler->get_fe().dofs_per_cell;
deallog << fe.get_name() << ' ' << fe.dofs_per_cell << ' ';
for (unsigned int i=0; i<fe.dofs_per_cell; ++i)
- for (unsigned int q=0; q<quadrature.n_quadrature_points; ++q)
+ for (unsigned int q=0; q<quadrature.size(); ++q)
for (unsigned int c=0; c<fe.n_components(); ++c)
{
const Point<dim> point = quadrature.point(q);
update_gradients |
update_JxW_values));
- const unsigned int n_q_points = quad.n_quadrature_points;
+ const unsigned int n_q_points = quad.size();
const unsigned int n_components = dof_handler->get_fe().n_components();
const unsigned int dofs_per_cell = dof_handler->get_fe().dofs_per_cell;
{
fe.reinit(c, face);
- for (unsigned int k=0; k<q.n_quadrature_points;++k)
+ for (unsigned int k=0; k<q.size();++k)
{
deallog << "Face " << face
<< " Point " << q.point(k) << std::endl;
v(i) = i;
FEValues<dim> feval(fe, quadrature, update_values);
- std::vector<Vector<double> > local(quadrature.n_quadrature_points,
+ std::vector<Vector<double> > local(quadrature.size(),
Vector<double>(fe.n_components()));
typename DoFHandler<dim>::active_cell_iterator cell = dof.begin_active();
for (unsigned int c=0;c<fe.n_components();++c)
{
deallog << "Component " << c;
- for (unsigned int k=0;k<quadrature.n_quadrature_points;++k)
+ for (unsigned int k=0;k<quadrature.size();++k)
deallog << '\t' << (int) local[k](c);
deallog << std::endl;
}
// $Id$
// Version: $Name$
//
-// Copyright (C) 2005, 2006, 2008 by the deal.II authors
+// Copyright (C) 2005, 2006, 2008, 2010 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
double result = 0.;
QGauss<dim> quadrature(fe.degree+1);
- std::vector<double> f(quadrature.n_quadrature_points);
+ std::vector<double> f(quadrature.size());
function.value_list(quadrature.get_points(), f);
- for (unsigned int k=0;k<quadrature.n_quadrature_points;++k)
+ for (unsigned int k=0;k<quadrature.size();++k)
{
double diff = f[k];
for (unsigned int i=0;i<dofs.size();++i)
double result = 0.;
QGauss<dim> quadrature(fe.degree+1);
- std::vector<Vector<double> > f(quadrature.n_quadrature_points,
+ std::vector<Vector<double> > f(quadrature.size(),
Vector<double>(function.n_components));
function.vector_value_list(quadrature.get_points(), f);
- for (unsigned int k=0;k<quadrature.n_quadrature_points;++k)
+ for (unsigned int k=0;k<quadrature.size();++k)
for (unsigned int comp=0;comp<fe.n_components();++comp)
{
double diff = f[k](comp+offset);
deallog.push(name);
QGauss<dim-1> q(4);
- const unsigned int nq = (unsigned int) (.01 + std::pow(q.n_quadrature_points, 1./(dim-1)));
+ const unsigned int nq = (unsigned int) (.01 + std::pow(q.size(), 1./(dim-1)));
FEFaceValues<dim> fe_values(mapping, fe, q,
UpdateFlags(update_q_points
deallog.push(name);
QGauss<dim-1> q(4);
- const unsigned int nq = (unsigned int) (.01 + std::pow(q.n_quadrature_points, 1./(dim-1)));
+ const unsigned int nq = (unsigned int) (.01 + std::pow(q.size(), 1./(dim-1)));
FESubfaceValues<dim> fe_values(mapping, fe, q,
UpdateFlags(update_q_points
typename DoFHandler<dim>::cell_iterator c = dof.begin();
fe_values.reinit(c);
- for (unsigned int k=0; k<quadrature_formula.n_quadrature_points; ++k)
+ for (unsigned int k=0; k<quadrature_formula.size(); ++k)
{
deallog << quadrature_formula.point(k) << std::endl;
deallog << "JxW: " << fe_values.JxW(k) << std::endl;
// mapping_q_eulerian.cc,v 1.3 2003/06/09 16:00:38 wolf Exp
// Version:
//
-// Copyright (C) 2008 by the deal.II authors and Joshua White
+// Copyright (C) 2008, 2010 by the deal.II authors and Joshua White
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
FEValues<dim> fe_values (mapping, fe, quadrature_formula,
update_JxW_values);
- const unsigned int n_q_points = quadrature_formula.n_quadrature_points;
+ const unsigned int n_q_points = quadrature_formula.size();
long double area = 0.;
// function on each cell and on
// each quadrature point
QTrapez<dim-1> quadrature;
- std::vector<Vector<double> > shape_values1 (quadrature.n_quadrature_points,
+ std::vector<Vector<double> > shape_values1 (quadrature.size(),
Vector<double>(dim));
- std::vector<Vector<double> > shape_values2 (quadrature.n_quadrature_points,
+ std::vector<Vector<double> > shape_values2 (quadrature.size(),
Vector<double>(dim));
MappingCartesian<dim> mapping;
// quadrature points of all cells
// of the finer grid
QTrapez<dim> quadrature;
- std::vector<Vector<double> > shape_values (quadrature.n_quadrature_points,
+ std::vector<Vector<double> > shape_values (quadrature.size(),
Vector<double>(dim));
FEValues<dim> fe(fe_ned, quadrature,
update_values|update_q_points);
fe.reinit(c);
fe.get_function_values (values, shape_values);
- for (unsigned int q=0; q<quadrature.n_quadrature_points; ++q)
+ for (unsigned int q=0; q<quadrature.size(); ++q)
{
deallog << ", xq=" << fe.quadrature_point(q)
<< ", f=[";
// non_primitive_1.cc,v 1.6 2003/04/21 07:31:15 guido Exp
// Version:
//
-// Copyright (C) 2001, 2002, 2003, 2005 by the deal.II authors
+// Copyright (C) 2001, 2002, 2003, 2005, 2010 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
FullMatrix<double> local_matrix (dofs_per_cell, dofs_per_cell);
QGauss<dim> quadrature (3);
- const unsigned int n_q_points = quadrature.n_quadrature_points;
+ const unsigned int n_q_points = quadrature.size();
FEValues<dim> fe_values (fe, quadrature,
update_values | update_gradients |
FullMatrix<double> local_matrix (dofs_per_cell, dofs_per_cell);
QGauss<dim> quadrature (3);
- const unsigned int n_q_points = quadrature.n_quadrature_points;
+ const unsigned int n_q_points = quadrature.size();
FEValues<dim> fe_values (fe, quadrature,
update_values | update_gradients |
FullMatrix<double> local_matrix (dofs_per_cell, dofs_per_cell);
QGauss<dim> quadrature (3);
- const unsigned int n_q_points = quadrature.n_quadrature_points;
+ const unsigned int n_q_points = quadrature.size();
FEValues<dim> fe_values (fe, quadrature,
update_values | update_gradients |
// non_primitive_2.cc,v 1.5 2003/04/21 07:31:15 guido Exp
// Version:
//
-// Copyright (C) 2001, 2002, 2003, 2005, 2007 by the deal.II authors
+// Copyright (C) 2001, 2002, 2003, 2005, 2007, 2010 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
FullMatrix<double> local_matrix (dofs_per_cell, dofs_per_cell);
QGauss<dim> quadrature (3);
- const unsigned int n_q_points = quadrature.n_quadrature_points;
+ const unsigned int n_q_points = quadrature.size();
FEValues<dim> fe_values (fe, quadrature,
update_values | update_gradients |
FullMatrix<double> local_matrix (dofs_per_cell, dofs_per_cell);
QGauss<dim> quadrature (3);
- const unsigned int n_q_points = quadrature.n_quadrature_points;
+ const unsigned int n_q_points = quadrature.size();
FEValues<dim> fe_values (fe, quadrature,
update_values | update_gradients |
// rt_10.cc,v 1.3 2003/06/09 16:00:38 wolf Exp
// Version:
//
-// Copyright (C) 2003, 2005, 2006 by the deal.II authors
+// Copyright (C) 2003, 2005, 2006, 2010 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
FEValues<dim> fe_values (fe_rt, quadrature, update_values);
fe_values.reinit (dof.begin_active());
- for (unsigned int q=0; q<quadrature.n_quadrature_points; ++q)
+ for (unsigned int q=0; q<quadrature.size(); ++q)
{
deallog << " Quadrature point " << q << ": ";
for (unsigned int i=0; i<fe_rt.dofs_per_cell; ++i)
// rt_11.cc,v 1.3 2003/06/09 16:00:38 wolf Exp
// Version:
//
-// Copyright (C) 2003, 2005, 2006 by the deal.II authors
+// Copyright (C) 2003, 2005, 2006, 2010 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
FEFaceValues<dim> fe_values (fe_rt, quadrature, update_values);
fe_values.reinit (dof.begin_active(), 0);
- for (unsigned int q=0; q<quadrature.n_quadrature_points; ++q)
+ for (unsigned int q=0; q<quadrature.size(); ++q)
{
deallog << " Quadrature point " << q << ": ";
for (unsigned int i=0; i<fe_rt.dofs_per_cell; ++i)
// rt_12.cc,v 1.3 2003/06/09 16:00:38 wolf Exp
// Version:
//
-// Copyright (C) 2003, 2005, 2006 by the deal.II authors
+// Copyright (C) 2003, 2005, 2006, 2010 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
FEValues<dim> fe_values (fe_rt, quadrature, update_gradients);
fe_values.reinit (dof.begin_active());
- for (unsigned int q=0; q<quadrature.n_quadrature_points; ++q)
+ for (unsigned int q=0; q<quadrature.size(); ++q)
{
deallog << " Quadrature point " << q << ": ";
for (unsigned int i=0; i<fe_rt.dofs_per_cell; ++i)
// rt_13.cc,v 1.3 2003/06/09 16:00:38 wolf Exp
// Version:
//
-// Copyright (C) 2003, 2005, 2006 by the deal.II authors
+// Copyright (C) 2003, 2005, 2006, 2010 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
FEFaceValues<dim> fe_values (fe_rt, quadrature, update_gradients);
fe_values.reinit (dof.begin_active(), 0);
- for (unsigned int q=0; q<quadrature.n_quadrature_points; ++q)
+ for (unsigned int q=0; q<quadrature.size(); ++q)
{
deallog << " Quadrature point " << q << ": ";
for (unsigned int i=0; i<fe_rt.dofs_per_cell; ++i)
// rt_14.cc,v 1.3 2003/06/09 16:00:38 wolf Exp
// Version:
//
-// Copyright (C) 2003, 2005, 2006 by the deal.II authors
+// Copyright (C) 2003, 2005, 2006, 2010 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
FESubfaceValues<dim> fe_values (fe_rt, quadrature, update_values);
fe_values.reinit (dof.begin_active(), 0, 0);
- for (unsigned int q=0; q<quadrature.n_quadrature_points; ++q)
+ for (unsigned int q=0; q<quadrature.size(); ++q)
{
deallog << " Quadrature point " << q << ": ";
for (unsigned int i=0; i<fe_rt.dofs_per_cell; ++i)
// rt_15.cc,v 1.3 2003/06/09 16:00:38 wolf Exp
// Version:
//
-// Copyright (C) 2003, 2005, 2006 by the deal.II authors
+// Copyright (C) 2003, 2005, 2006, 2010 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
FESubfaceValues<dim> fe_values (fe_rt, quadrature, update_gradients);
fe_values.reinit (dof.begin_active(), 0, 0);
- for (unsigned int q=0; q<quadrature.n_quadrature_points; ++q)
+ for (unsigned int q=0; q<quadrature.size(); ++q)
{
deallog << " Quadrature point " << q << ": ";
for (unsigned int i=0; i<fe_rt.dofs_per_cell; ++i)
// rt_7.cc,v 1.3 2003/06/09 16:00:38 wolf Exp
// Version:
//
-// Copyright (C) 2003, 2005 by the deal.II authors
+// Copyright (C) 2003, 2005, 2010 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
Assert (fe.get_fe().n_components() == dim, ExcInternalError());
- for (unsigned int q_point=0; q_point<q.n_quadrature_points; ++q_point)
+ for (unsigned int q_point=0; q_point<q.size(); ++q_point)
{
- if (q_point % QIterated<1>(q_trapez,div).n_quadrature_points == 0)
+ if (q_point % QIterated<1>(q_trapez,div).size() == 0)
deallog << std::endl;
deallog << fe.quadrature_point(q_point) << " ";
Assert (fe.get_fe().n_components() == dim, ExcInternalError());
- for (unsigned int q_point=0; q_point<q.n_quadrature_points; ++q_point)
+ for (unsigned int q_point=0; q_point<q.size(); ++q_point)
for (unsigned int i=0; i<dofs_per_cell; ++i)
for (unsigned int j=0; j<dofs_per_cell; ++j)
for (unsigned int d=0; d<dim; ++d)
update_JxW_values|
update_contravariant_transformation));
- const unsigned int n_q_points = quad.n_quadrature_points;
+ const unsigned int n_q_points = quad.size();
const unsigned int n_components = dof_handler->get_fe().n_components();
// Cell iterators
<< ", dofs per line: " << fe.dofs_per_line
<< ", dofs per vertex: " << fe.dofs_per_vertex
<< std::endl;
- deallog << "n_q_points=" << quad_temp.n_quadrature_points
+ deallog << "n_q_points=" << quad_temp.size()
<< std::endl;
// Create an deformation object for
// rt_normal_02.cc,v 1.3 2003/06/09 16:00:38 wolf Exp
// Version:
//
-// Copyright (C) 2003, 2005, 2006 by the deal.II authors
+// Copyright (C) 2003, 2005, 2006, 2010 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
update_gradients |
update_JxW_values));
- const unsigned int n_q_face = quad.n_quadrature_points;
- const unsigned int n_q_proj = qproject.n_quadrature_points;
+ const unsigned int n_q_face = quad.size();
+ const unsigned int n_q_proj = qproject.size();
const unsigned int n_components = dof_handler->get_fe().n_components();
const unsigned int dofs_per_cell = dof_handler->get_fe().dofs_per_cell;
cell->face_orientation(f),
cell->face_flip(f),
cell->face_rotation(f),
- quad.n_quadrature_points));
+ quad.size()));
fe_v_face.reinit (cell, f);
DoFHandler<2>::active_cell_iterator cell_n = cell->neighbor (f);
cell_n->face_orientation(neighbor),
cell_n->face_flip(neighbor),
cell_n->face_rotation(neighbor),
- quad.n_quadrature_points));
+ quad.size()));
// Get values from solution vector (For Trap.Rule)
std::vector<Vector<double> > this_value
update_normal_vectors |
update_JxW_values));
- const unsigned int n_q_face = quad.n_quadrature_points;
+ const unsigned int n_q_face = quad.size();
const unsigned int n_components = dof_handler->get_fe().n_components();
const unsigned int dofs_per_cell = dof_handler->get_fe().dofs_per_cell;
// rt_1.cc,v 1.3 2003/06/09 16:00:38 wolf Exp
// Version:
//
-// Copyright (C) 2005 by the deal.II authors
+// Copyright (C) 2005, 2010 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
FullMatrix<double>& M)
{
QGauss<dim> quadrature(other.degree+1);
- Table<3,double> other_values(quadrature.n_quadrature_points, other.dofs_per_cell, dim);
- Table<3,double> nodes_values(quadrature.n_quadrature_points, other.dofs_per_cell, dim);
- Table<3,Tensor<1,dim> > other_grads(quadrature.n_quadrature_points, other.dofs_per_cell, dim);
- Table<3,Tensor<1,dim> > nodes_grads(quadrature.n_quadrature_points, other.dofs_per_cell, dim);
- for (unsigned int k=0;k<quadrature.n_quadrature_points;++k)
+ Table<3,double> other_values(quadrature.size(), other.dofs_per_cell, dim);
+ Table<3,double> nodes_values(quadrature.size(), other.dofs_per_cell, dim);
+ Table<3,Tensor<1,dim> > other_grads(quadrature.size(), other.dofs_per_cell, dim);
+ Table<3,Tensor<1,dim> > nodes_grads(quadrature.size(), other.dofs_per_cell, dim);
+ for (unsigned int k=0;k<quadrature.size();++k)
for (unsigned int i=0;i<other.dofs_per_cell;++i)
for (unsigned int d=0;d<dim;++d)
{
nodes_grads[k][i][d] = nodes.shape_grad_component(i,quadrature.point(k),d);
}
- for (unsigned int k=0;k<quadrature.n_quadrature_points;++k)
+ for (unsigned int k=0;k<quadrature.size();++k)
{
for (unsigned int i=0;i<other.dofs_per_cell;++i)
for (unsigned int d=0;d<dim;++d)
// rtn_2.cc,v 1.3 2003/06/09 16:00:38 wolf Exp
// Version:
//
-// Copyright (C) 2003, 2005, 2006, 2008 by the deal.II authors
+// Copyright (C) 2003, 2005, 2006, 2008, 2010 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
FEValues<dim> fe(fe_rt, q, update_values|update_gradients|update_q_points);
fe.reinit(c);
- for (unsigned int q_point=0; q_point<q.n_quadrature_points; ++q_point)
+ for (unsigned int q_point=0; q_point<q.size(); ++q_point)
{
- if (q_point % QIterated<1>(q_trapez,div).n_quadrature_points == 0)
+ if (q_point % QIterated<1>(q_trapez,div).size() == 0)
deallog << std::endl;
deallog << fe.quadrature_point(q_point) << " ";
const Quadrature<dim> &q)
{
// check values
- for (unsigned int x=0; x<q.n_quadrature_points; ++x)
+ for (unsigned int x=0; x<q.size(); ++x)
for (unsigned int i=0; i<fe.dofs_per_cell; ++i)
{
for (unsigned int c=0; c<fe.n_components(); ++c)
};
// check gradients
- for (unsigned int x=0; x<q.n_quadrature_points; ++x)
+ for (unsigned int x=0; x<q.size(); ++x)
for (unsigned int i=0; i<fe.dofs_per_cell; ++i)
{
for (unsigned int c=0; c<fe.n_components(); ++c)
// check second derivatives
double max_diff=0.;
- for (unsigned int x=0; x<q.n_quadrature_points; ++x)
+ for (unsigned int x=0; x<q.size(); ++x)
for (unsigned int i=0; i<fe.dofs_per_cell; ++i)
{
for (unsigned int c=0; c<fe.n_components(); ++c)
// $Id$
// Version: $Name$
//
-// Copyright (C) 2006, 2007, 2008, 2009 by the deal.II authors
+// Copyright (C) 2006, 2007, 2008, 2009, 2010 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
for (unsigned int i=0; i<fe_collection[fe].dofs_per_cell; ++i)
{
std::complex<double> sum = 0;
- for (unsigned int q=0; q<quadrature.n_quadrature_points; ++q)
+ for (unsigned int q=0; q<quadrature.size(); ++q)
{
const Point<dim> x_q = quadrature.point(q);
sum += std::exp(std::complex<double>(0,1) *
// $Id$
// Version: $Name$
//
-// Copyright (C) 2006, 2007, 2008, 2009 by the deal.II authors
+// Copyright (C) 2006, 2007, 2008, 2009, 2010 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
for (unsigned int i=0; i<fe_collection[fe].dofs_per_cell; ++i)
{
std::complex<double> sum = 0;
- for (unsigned int q=0; q<quadrature.n_quadrature_points; ++q)
+ for (unsigned int q=0; q<quadrature.size(); ++q)
{
const Point<dim> x_q = quadrature.point(q);
sum += std::exp(std::complex<double>(0,1) *
// $Id$
// Version: $Name$
//
-// Copyright (C) 2006, 2007, 2008 by the deal.II authors
+// Copyright (C) 2006, 2007, 2008, 2010 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
for (unsigned int i=0; i<fe_collection[fe].dofs_per_cell; ++i)
{
std::complex<double> sum = 0;
- for (unsigned int q=0; q<quadrature.n_quadrature_points; ++q)
+ for (unsigned int q=0; q<quadrature.size(); ++q)
{
const Point<dim> x_q = quadrature.point(q);
sum += std::exp(std::complex<double>(0,1) *
// $Id$
// Version: $Name$
//
-// Copyright (C) 2006, 2007, 2008 by the deal.II authors
+// Copyright (C) 2006, 2007, 2008, 2010 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
for (unsigned int i=0; i<fe_collection[fe].dofs_per_cell; ++i)
{
std::complex<double> sum = 0;
- for (unsigned int q=0; q<quadrature.n_quadrature_points; ++q)
+ for (unsigned int q=0; q<quadrature.size(); ++q)
{
const Point<dim> x_q = quadrature.point(q);
sum += std::exp(std::complex<double>(0,1) *
// $Id$
// Version: $Name$
//
-// Copyright (C) 2005, 2006, 2007, 2008 by the deal.II authors
+// Copyright (C) 2005, 2006, 2007, 2008, 2010 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
update_gradients | update_JxW_values);
const unsigned int dofs_per_cell = (*fe)[0].dofs_per_cell;
- const unsigned int n_q_points = (*quadrature)[0].n_quadrature_points;
+ const unsigned int n_q_points = (*quadrature)[0].size();
FullMatrix<double> cell_matrix (dofs_per_cell, dofs_per_cell);
update_JxW_values);
const unsigned int dofs_per_cell = (*this->fe)[0].dofs_per_cell;
- const unsigned int n_q_points = (*this->quadrature)[0].n_quadrature_points;
+ const unsigned int n_q_points = (*this->quadrature)[0].size();
Vector<double> cell_rhs (dofs_per_cell);
std::vector<double> rhs_values (n_q_points);
// $Id$
// Version: $Name$
//
-// Copyright (C) 2005, 2006, 2008 by the deal.II authors
+// Copyright (C) 2005, 2006, 2008, 2010 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 | update_gradients | update_JxW_values);
const unsigned int dofs_per_cell = fe[0].dofs_per_cell;
- const unsigned int n_q_points = quadrature_formula[0].n_quadrature_points;
+ const unsigned int n_q_points = quadrature_formula[0].size();
FullMatrix<double> cell_matrix (dofs_per_cell, dofs_per_cell);
Vector<double> cell_rhs (dofs_per_cell);
// $Id$
// Version: $Name$
//
-// Copyright (C) 2005, 2006 by the deal.II authors
+// Copyright (C) 2005, 2006, 2010 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 | update_gradients | update_JxW_values);
const unsigned int max_dofs_per_cell = fe.max_dofs_per_cell ();
- const unsigned int n_q_points = quadrature_formula[0].n_quadrature_points;
+ const unsigned int n_q_points = quadrature_formula[0].size();
FullMatrix<double> cell_matrix (max_dofs_per_cell, max_dofs_per_cell);
Vector<double> cell_rhs (max_dofs_per_cell);
// $Id$
// Version: $Name$
//
-// Copyright (C) 2005, 2006 by the deal.II authors
+// Copyright (C) 2005, 2006, 2010 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 | update_gradients | update_JxW_values);
const unsigned int max_dofs_per_cell = fe.max_dofs_per_cell ();
- const unsigned int n_q_points = quadrature_formula[0].n_quadrature_points;
+ const unsigned int n_q_points = quadrature_formula[0].size();
FullMatrix<double> cell_matrix (max_dofs_per_cell, max_dofs_per_cell);
Vector<double> cell_rhs (max_dofs_per_cell);
// $Id$
// Version: $Name$
//
-// Copyright (C) 2005, 2006 by the deal.II authors
+// Copyright (C) 2005, 2006, 2010 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
cell_rhs = 0;
const unsigned int dofs_per_cell = cell->get_fe ().dofs_per_cell;
- const unsigned int n_q_points = quadrature_formula[cell->active_fe_index ()].n_quadrature_points;
+ const unsigned int n_q_points = quadrature_formula[cell->active_fe_index ()].size();
for (unsigned int i=0; i<dofs_per_cell; ++i)
for (unsigned int j=0; j<dofs_per_cell; ++j)
for (unsigned int q_point=0; q_point<n_q_points; ++q_point)
// $Id$
// Version: $Name$
//
-// Copyright (C) 2005, 2006, 2007, 2008 by the deal.II authors
+// Copyright (C) 2005, 2006, 2007, 2008, 2010 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
update_q_points | update_JxW_values);
const unsigned int dofs_per_cell = fe[0].dofs_per_cell;
- const unsigned int n_q_points = quadrature_formula[0].n_quadrature_points;
+ const unsigned int n_q_points = quadrature_formula[0].size();
FullMatrix<double> cell_matrix (dofs_per_cell, dofs_per_cell);
Vector<double> cell_rhs (dofs_per_cell);
// $Id$
// Version: $Name$
//
-// Copyright (C) 2005, 2006, 2007, 2008 by the deal.II authors
+// Copyright (C) 2005, 2006, 2007, 2008, 2010 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
update_q_points | update_JxW_values);
const unsigned int dofs_per_cell = fe[0].dofs_per_cell;
- const unsigned int n_q_points = quadrature_formula[0].n_quadrature_points;
+ const unsigned int n_q_points = quadrature_formula[0].size();
FullMatrix<double> cell_matrix (dofs_per_cell, dofs_per_cell);
Vector<double> cell_rhs (dofs_per_cell);
// $Id$
// Version: $Name$
//
-// Copyright (C) 2005, 2006, 2007, 2008 by the deal.II authors
+// Copyright (C) 2005, 2006, 2007, 2008, 2010 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
update_q_points | update_JxW_values);
const unsigned int dofs_per_cell = fe[0].dofs_per_cell;
- const unsigned int n_q_points = quadrature_formula[0].n_quadrature_points;
+ const unsigned int n_q_points = quadrature_formula[0].size();
FullMatrix<double> cell_matrix (dofs_per_cell, dofs_per_cell);
Vector<double> cell_rhs (dofs_per_cell);
// $Id$
// Version: $Name$
//
-// Copyright (C) 2005, 2006, 2007, 2008 by the deal.II authors
+// Copyright (C) 2005, 2006, 2007, 2008, 2010 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
hp::QCollection<dim> quadrature_formula(QGauss<dim>(3));
hp::QCollection<dim-1> face_quadrature_formula(QGauss<dim-1>(3));
- const unsigned int n_q_points = quadrature_formula[0].n_quadrature_points;
- const unsigned int n_face_q_points = face_quadrature_formula[0].n_quadrature_points;
+ const unsigned int n_q_points = quadrature_formula[0].size();
+ const unsigned int n_face_q_points = face_quadrature_formula[0].size();
const unsigned int dofs_per_cell = (*fe)[0].dofs_per_cell;
// $Id$
// Version: $Name$
//
-// Copyright (C) 2005, 2006, 2008 by the deal.II authors
+// Copyright (C) 2005, 2006, 2008, 2010 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
update_q_points | update_JxW_values);
const unsigned int dofs_per_cell = fe[0].dofs_per_cell;
- const unsigned int n_q_points = quadrature_formula[0].n_quadrature_points;
+ const unsigned int n_q_points = quadrature_formula[0].size();
FullMatrix<double> cell_matrix (dofs_per_cell, dofs_per_cell);
Vector<double> cell_rhs (dofs_per_cell);
MeshWorker::IntegrationInfoBox<dim> info_box;
UpdateFlags update_flags = update_values | update_gradients;
- info_box.add_update_flags(update_flags, true, true, true, true);
+ info_box.add_update_flags_cell(update_flags);
info_box.initialize(fe, mapping, &dof.block_info());
+ if (debugging)
+ deallog << "Infobox ready" << std::endl;
MeshWorker::DoFInfo<dim> dof_info(dof.block_info());
for (unsigned int i=0;i<matrices.block(b).matrix.m();++i)
if (matrices.block(b).matrix.diag_element(i) == 0.)
matrices.block(b).matrix.diag_element(i) = 1.;
-
+ if (debugging)
+ deallog << "Matrices ready" << std::endl;
// Set up vectors
BlockVector<double> source(dof.block_info().global());
BlockVector<double> result1(dof.block_info().global());
matrices.matrix(m+2).vmult(result1.block(d+1), source.block(d));
- solver.solve(matrices.matrix(m+3), aux.block(d+1), result1.block(d+1), PreconditionIdentity());
+ PreconditionSSOR<SparseMatrix<double> > precondition;
+ precondition.initialize(matrices.matrix(m+3), 1.2);
+
+ solver.solve(matrices.matrix(m+3), aux.block(d+1), result1.block(d+1), precondition);
matrices.matrix(m+2).Tvmult(result1.block(d), aux.block(d+1));
matrices.matrix(m+1).vmult(result2.block(d), source.block(d));
const std::string logname = JobIdentifier::base_name(__FILE__) + std::string("/output");
std::ofstream logfile(logname.c_str());
deallog.attach(logfile);
+ deallog.log_execution_time(true);
if (!debugging)
{
deallog.depth_console(0);
-DEAL:d2-p0::Setup
-DEAL:d2-p0::Triangulation hypercube 2D refinement 1 steps 4 active cells 5 total cells
-DEAL:d2-p0::Form 0
-DEAL:d2-p0::Difference d*d 0
-DEAL:d2-p0::Form 1
-DEAL:d2-p0::d^2 0
-DEAL:d2-p0::d*d^2 0
-DEAL:d2-p0::Difference d*d 0
-DEAL:d2-p0::Triangulation hypercube 2D refinement 2 local steps 7 active cells 9 total cells
-DEAL:d2-p0::Form 0
-DEAL:d2-p0::Difference d*d 0
-DEAL:d2-p0::Form 1
-DEAL:d2-p0::d^2 0
-DEAL:d2-p0::d*d^2 0
-DEAL:d2-p0::Difference d*d 0
-DEAL:d2-p0::Triangulation hypercube 2D refinement 3 local steps 25 active cells 33 total cells
-DEAL:d2-p0::Form 0
-DEAL:d2-p0::Difference d*d 0
-DEAL:d2-p0::Form 1
-DEAL:d2-p0::d^2 0
-DEAL:d2-p0::d*d^2 0
-DEAL:d2-p0::Difference d*d 0
-DEAL:d2-p1::Setup
-DEAL:d2-p1::Triangulation hypercube 2D refinement 1 steps 4 active cells 5 total cells
-DEAL:d2-p1::Form 0
-DEAL:d2-p1::Difference d*d 0
-DEAL:d2-p1::Form 1
-DEAL:d2-p1::d^2 0
-DEAL:d2-p1::d*d^2 0
-DEAL:d2-p1::Difference d*d 0
-DEAL:d2-p1::Triangulation hypercube 2D refinement 2 local steps 7 active cells 9 total cells
-DEAL:d2-p1::Form 0
-DEAL:d2-p1::Difference d*d 0
-DEAL:d2-p1::Form 1
-DEAL:d2-p1::d^2 0
-DEAL:d2-p1::d*d^2 0
-DEAL:d2-p1::Difference d*d 0
-DEAL:d2-p1::Triangulation hypercube 2D refinement 3 local steps 25 active cells 33 total cells
-DEAL:d2-p1::Form 0
-DEAL:d2-p1::Difference d*d 0
-DEAL:d2-p1::Form 1
-DEAL:d2-p1::d^2 0
-DEAL:d2-p1::d*d^2 0
-DEAL:d2-p1::Difference d*d 0
-DEAL:d2-p2::Setup
-DEAL:d2-p2::Triangulation hypercube 2D refinement 1 steps 4 active cells 5 total cells
-DEAL:d2-p2::Form 0
-DEAL:d2-p2::Difference d*d 0
-DEAL:d2-p2::Form 1
-DEAL:d2-p2::d^2 0
-DEAL:d2-p2::d*d^2 0
-DEAL:d2-p2::Difference d*d 0
-DEAL:d2-p2::Triangulation hypercube 2D refinement 2 local steps 7 active cells 9 total cells
-DEAL:d2-p2::Form 0
-DEAL:d2-p2::Difference d*d 0
-DEAL:d2-p2::Form 1
-DEAL:d2-p2::d^2 0
-DEAL:d2-p2::d*d^2 0
-DEAL:d2-p2::Difference d*d 0
-DEAL:d2-p2::Triangulation hypercube 2D refinement 3 local steps 25 active cells 33 total cells
-DEAL:d2-p2::Form 0
-DEAL:d2-p2::Difference d*d 0
-DEAL:d2-p2::Form 1
-DEAL:d2-p2::d^2 0
-DEAL:d2-p2::d*d^2 0
-DEAL:d2-p2::Difference d*d 0
-DEAL:d3-p0::Setup
-DEAL:d3-p0::Triangulation hypercube 3D refinement 1 steps 8 active cells 9 total cells
-DEAL:d3-p0::Form 0
-DEAL:d3-p0::Difference d*d 0
-DEAL:d3-p0::Form 1
-DEAL:d3-p0::d^2 0
-DEAL:d3-p0::d*d^2 0
-DEAL:d3-p0::Difference d*d 0
-DEAL:d3-p0::Form 2
-DEAL:d3-p0::d^2 0
-DEAL:d3-p0::d*d^2 0
-DEAL:d3-p0::Difference d*d 0
-DEAL:d3-p1::Setup
-DEAL:d3-p1::Triangulation hypercube 3D refinement 1 steps 8 active cells 9 total cells
-DEAL:d3-p1::Form 0
-DEAL:d3-p1::Difference d*d 0
-DEAL:d3-p1::Form 1
-DEAL:d3-p1::d^2 0
-DEAL:d3-p1::d*d^2 0
-DEAL:d3-p1::Difference d*d 0
-DEAL:d3-p1::Form 2
-DEAL:d3-p1::d^2 0
-DEAL:d3-p1::d*d^2 0
-DEAL:d3-p1::Difference d*d 0
+0.0200000:DEAL:d2-p0::Setup
+0.0600000:DEAL:d2-p0::Triangulation hypercube 2D refinement 1 steps 4 active cells 5 total cells
+0.460000:DEAL:d2-p0::Form 0
+0.480000:DEAL:d2-p0::Difference d*d 0
+0.480000:DEAL:d2-p0::Form 1
+0.480000:DEAL:d2-p0::d^2 0
+0.480000:DEAL:d2-p0::d*d^2 0
+0.480000:DEAL:d2-p0::Difference d*d 0
+0.480000:DEAL:d2-p0::Triangulation hypercube 2D refinement 2 local steps 7 active cells 9 total cells
+0.940000:DEAL:d2-p0::Form 0
+0.940000:DEAL:d2-p0::Difference d*d 0
+0.940000:DEAL:d2-p0::Form 1
+0.940000:DEAL:d2-p0::d^2 0
+0.940000:DEAL:d2-p0::d*d^2 0
+0.950000:DEAL:d2-p0::Difference d*d 0
+0.950000:DEAL:d2-p0::Triangulation hypercube 2D refinement 3 local steps 25 active cells 33 total cells
+1.37000:DEAL:d2-p0::Form 0
+1.41000:DEAL:d2-p0::Difference d*d 0
+1.41000:DEAL:d2-p0::Form 1
+1.41000:DEAL:d2-p0::d^2 0
+1.41000:DEAL:d2-p0::d*d^2 0
+1.41000:DEAL:d2-p0::Difference d*d 0
+1.41000:DEAL:d2-p1::Setup
+1.49000:DEAL:d2-p1::Triangulation hypercube 2D refinement 1 steps 4 active cells 5 total cells
+1.95000:DEAL:d2-p1::Form 0
+1.95000:DEAL:d2-p1::Difference d*d 0
+1.95000:DEAL:d2-p1::Form 1
+1.95000:DEAL:d2-p1::d^2 0
+1.95000:DEAL:d2-p1::d*d^2 0
+1.95000:DEAL:d2-p1::Difference d*d 0
+1.95000:DEAL:d2-p1::Triangulation hypercube 2D refinement 2 local steps 7 active cells 9 total cells
+2.46000:DEAL:d2-p1::Form 0
+2.48000:DEAL:d2-p1::Difference d*d 0
+2.49000:DEAL:d2-p1::Form 1
+2.49000:DEAL:d2-p1::d^2 0
+2.49000:DEAL:d2-p1::d*d^2 0
+2.49000:DEAL:d2-p1::Difference d*d 0
+2.50000:DEAL:d2-p1::Triangulation hypercube 2D refinement 3 local steps 25 active cells 33 total cells
+3.07000:DEAL:d2-p1::Form 0
+3.12000:DEAL:d2-p1::Difference d*d 0
+3.12000:DEAL:d2-p1::Form 1
+3.12000:DEAL:d2-p1::d^2 0
+3.12000:DEAL:d2-p1::d*d^2 0
+3.12000:DEAL:d2-p1::Difference d*d 0
+3.12000:DEAL:d2-p2::Setup
+3.36000:DEAL:d2-p2::Triangulation hypercube 2D refinement 1 steps 4 active cells 5 total cells
+4.30000:DEAL:d2-p2::Form 0
+4.30000:DEAL:d2-p2::Difference d*d 0
+4.31000:DEAL:d2-p2::Form 1
+4.31000:DEAL:d2-p2::d^2 0
+4.31000:DEAL:d2-p2::d*d^2 0
+4.31000:DEAL:d2-p2::Difference d*d 0
+4.31000:DEAL:d2-p2::Triangulation hypercube 2D refinement 2 local steps 7 active cells 9 total cells
+5.27000:DEAL:d2-p2::Form 0
+5.29000:DEAL:d2-p2::Difference d*d 0
+5.29000:DEAL:d2-p2::Form 1
+5.29000:DEAL:d2-p2::d^2 0
+5.29000:DEAL:d2-p2::d*d^2 0
+5.32000:DEAL:d2-p2::Difference d*d 0
+5.32000:DEAL:d2-p2::Triangulation hypercube 2D refinement 3 local steps 25 active cells 33 total cells
+6.77000:DEAL:d2-p2::Form 0
+6.90000:DEAL:d2-p2::Difference d*d 0
+6.90000:DEAL:d2-p2::Form 1
+6.90000:DEAL:d2-p2::d^2 0
+6.91000:DEAL:d2-p2::d*d^2 0
+6.95000:DEAL:d2-p2::Difference d*d 0
+6.95000:DEAL:d3-p0::Setup
+7.06000:DEAL:d3-p0::Triangulation hypercube 3D refinement 1 steps 8 active cells 9 total cells
+8.44000:DEAL:d3-p0::Form 0
+8.44000:DEAL:d3-p0::Difference d*d 0
+8.44000:DEAL:d3-p0::Form 1
+8.45000:DEAL:d3-p0::d^2 0
+8.45000:DEAL:d3-p0::d*d^2 0
+8.46000:DEAL:d3-p0::Difference d*d 0
+8.46000:DEAL:d3-p0::Form 2
+8.46000:DEAL:d3-p0::d^2 0
+8.46000:DEAL:d3-p0::d*d^2 0
+8.46000:DEAL:d3-p0::Difference d*d 0
+8.47000:DEAL:d3-p0::Triangulation hypercube 3D refinement 2 local steps 15 active cells 17 total cells
+9.94000:DEAL:d3-p0::Form 0
+9.98000:DEAL:d3-p0::Difference d*d 0
+9.98000:DEAL:d3-p0::Form 1
+9.98000:DEAL:d3-p0::d^2 0
+9.98000:DEAL:d3-p0::d*d^2 0
+9.99000:DEAL:d3-p0::Difference d*d 0
+9.99000:DEAL:d3-p0::Form 2
+9.99000:DEAL:d3-p0::d^2 0
+9.99000:DEAL:d3-p0::d*d^2 0
+9.99000:DEAL:d3-p0::Difference d*d 0
+9.99000:DEAL:d3-p1::Setup
+16.8400:DEAL:d3-p1::Triangulation hypercube 3D refinement 1 steps 8 active cells 9 total cells
+29.4100:DEAL:d3-p1::Form 0
+29.5100:DEAL:d3-p1::Difference d*d 0
+29.5100:DEAL:d3-p1::Form 1
+29.5100:DEAL:d3-p1::d^2 0
+29.5100:DEAL:d3-p1::d*d^2 0
+29.5500:DEAL:d3-p1::Difference d*d 0
+29.5500:DEAL:d3-p1::Form 2
+29.5500:DEAL:d3-p1::d^2 0
+29.5500:DEAL:d3-p1::d*d^2 0
+29.5500:DEAL:d3-p1::Difference d*d 0
+29.5700:DEAL:d3-p1::Triangulation hypercube 3D refinement 2 local steps 15 active cells 17 total cells
+47.7600:DEAL:d3-p1::Form 0
+48.3300:DEAL:d3-p1::Difference d*d 0
+48.3300:DEAL:d3-p1::Form 1
+48.3300:DEAL:d3-p1::d^2 0
+48.3300:DEAL:d3-p1::d*d^2 0
+48.4100:DEAL:d3-p1::Difference d*d 0
+48.4100:DEAL:d3-p1::Form 2
+48.4100:DEAL:d3-p1::d^2 0
+48.4200:DEAL:d3-p1::d*d^2 0
+48.4200:DEAL:d3-p1::Difference d*d 0
// $Id$
// Version: $Name$
//
-// Copyright (C) 2002, 2003, 2004, 2005, 2006, 2009 by the deal.II authors
+// Copyright (C) 2002, 2003, 2004, 2005, 2006, 2009, 2010 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 | update_gradients | update_JxW_values);
const unsigned int dofs_per_cell = fe.dofs_per_cell;
- const unsigned int n_q_points = quadrature_formula.n_quadrature_points;
+ const unsigned int n_q_points = quadrature_formula.size();
FullMatrix<double> cell_matrix (dofs_per_cell, dofs_per_cell);
Vector<double> cell_rhs (dofs_per_cell);
projects / dealii.git / commitdiff