// the unit support points to
// enquire the location of the
// support points in real space
- Quadrature<dim> q_dummy(dof_handler.get_fe().get_unit_support_points(),
- std::vector<double> (dofs_per_cell,
- 1./dofs_per_cell));
+ //
+ // the weights of the quadrature
+ // rule are set to invalid values
+ // by the used constructor.
+ Quadrature<dim> q_dummy(dof_handler.get_fe().get_unit_support_points());
FEValues<dim> fe_values (mapping, dof_handler.get_fe(),
q_dummy, update_q_points);
typename DoFHandler<dim>::active_cell_iterator
// FEValues objects with slightly
// shifted positions
std::vector<Point<dim> > diff_points (quadrature.n_quadrature_points);
- std::vector<double> diff_weights (quadrature.n_quadrature_points, 0);
differences.resize(2*dim);
for (unsigned int d=0; d<dim; ++d)
// gradients, not more
for (unsigned int i=0; i<diff_points.size(); ++i)
diff_points[i] = quadrature.point(i) + shift;
- const Quadrature<dim> plus_quad (diff_points, diff_weights);
+ const Quadrature<dim> plus_quad (diff_points);
differences[d] = new FEValues<dim> (mapping, *element,
plus_quad, update_gradients);
// now same in minus-direction
for (unsigned int i=0; i<diff_points.size(); ++i)
diff_points[i] = quadrature.point(i) - shift;
- const Quadrature<dim> minus_quad (diff_points, diff_weights);
+ const Quadrature<dim> minus_quad (diff_points);
differences[d+dim] = new FEValues<dim> (mapping, *element,
minus_quad, update_gradients);
}
// Initialize FEValues for fe1 at
// the unit support points of the
// fe2 element.
- std::vector<double> phantom_weights(fe2.dofs_per_cell,1.);
const typename std::vector<Point<dim> > &
fe2_support_points = fe2.get_unit_support_points ();
- Quadrature<dim> fe2_support_points_quadrature(fe2_support_points,
- phantom_weights);
+ Quadrature<dim> fe2_support_points_quadrature(fe2_support_points);
// This is a bad workaround as we
// can't ask the FEs for their
GridGenerator::hyper_cube(tria);
dof_handler.distribute_dofs(fe1);
MappingQ1<dim> mapping_q1;
- FEValues<dim> fe_values(mapping_q1, fe1, fe2_support_points_quadrature, update_values);
+ FEValues<dim> fe_values(mapping_q1, fe1, fe2_support_points_quadrature,
+ update_values);
fe_values.reinit(dof_handler.begin_active());
for (unsigned int i=0; i<fe2.dofs_per_cell; ++i)
for (unsigned int i=0; i<n_points; ++i)
boundary_points[i](0)= 1.*(i+1)/(n_points+1);
- Quadrature<dim-1> quadrature(boundary_points, std::vector<double> (n_points, 1));
+ Quadrature<dim-1> quadrature(boundary_points);
q_projector = new QProjector<dim> (quadrature, false);
}
for (unsigned int i=0; i<n_points; ++i)
boundary_points[i](0) = 1.*(i+1)/(n_points+1);
- Quadrature<dim-1> quadrature (boundary_points,
- std::vector<double> (n_points, 1));
+ Quadrature<dim-1> quadrature (boundary_points);
QProjector<dim> q_projector (quadrature, false);
// next loop over all
Assert(dof_to_rep_index_table.size()==fe.dofs_per_cell, ExcInternalError());
std::vector<unsigned int> dofs_on_cell (fe.dofs_per_cell);
- std::vector<double> dummy_weights (fe.dofs_per_cell);
-
std::vector<Point<dim> > rep_points (n_rep_points);
// get space for the values of the
// Make a quadrature rule from support points
// to feed it into FEValues
- Quadrature<dim> support_quadrature(unit_support_points, dummy_weights);
+ Quadrature<dim> support_quadrature(unit_support_points);
// Transformed support points are computed by
// FEValues
// used in this function
Assert (unit_support_points.size() != 0, ExcNonInterpolatingFE());
- std::vector<double> dummy_weights (unit_support_points.size());
- Quadrature<dim-1> aux_quad (unit_support_points, dummy_weights);
+ Quadrature<dim-1> aux_quad (unit_support_points);
FEFaceValues<dim> fe_values (mapping, fe, aux_quad, update_q_points);
typename DoFHandler<dim>::active_cell_iterator cell = dof.begin_active(),