contravariant
};
+
+
+ /**
+ * On noncartesian grids, the
+ * sign of the DoFs associated with
+ * the faces of the elements has
+ * to be changed in some cases.
+ * This procedure implements an
+ * algorithm, which determines
+ * the DoFs, which need this
+ * sign change for a given cell.
+ */
+ void get_face_sign_change (const typename Triangulation<dim>::cell_iterator &cell,
+ std::vector<double> &face_sign) const;
+
+
/**
* The mapping type to be used to
* map shape functions from the
* transformation defined by
* the Mapping.
*/
- update_transformation_gradients = 0x1000
+ update_transformation_gradients = 0x1000,
+
+ /**
+ * Compute the JxW values
+ * on faces for the cell mapping
+ * and not the face mapping!
+ * This functionality is required
+ * for the Piola mapping which
+ * is used in conjunction with
+ * H_div subspaces like RT and ABF.
+ */
+ update_cell_JxW_values = 0x2000
+
};
*/
std::vector<double> JxW_values;
+ /**
+ * Store an array of weights
+ * times the Jacobi determinant
+ * at the quadrature points. This
+ * function is reset each time
+ * reinit() is called. The
+ * Jacobi determinant is actually
+ * the reciprocal value of the
+ * Jacobi matrices stored in this
+ * class, see the general
+ * documentation of this class
+ * for more information.
+ *
+ * In contrast to JxW_values,
+ * this vector uses the transformation
+ * of the cell even in case the
+ * corresponding FEValues object
+ * refers to a face. Currently the
+ * only purpose is to provide
+ * exactly this value to the
+ * transformation which is used
+ * for the PolyTensor elements.
+ */
+ std::vector<double> cell_JxW_values;
+
/**
* Array of quadrature points. This array
* is set up upon calling reinit() and
std::vector<Point<dim> > &quadrature_points,
std::vector<double> &JxW_values,
std::vector<Tensor<1,dim> > &boundary_form,
- std::vector<Point<dim> > &normal_vectors) const = 0;
+ std::vector<Point<dim> > &normal_vectors,
+ std::vector<double> &cell_JxW_values) const = 0;
/**
* See above.
std::vector<Point<dim> > &quadrature_points,
std::vector<double> &JxW_values,
std::vector<Tensor<1,dim> > &boundary_form,
- std::vector<Point<dim> > &normal_vectors) const = 0;
+ std::vector<Point<dim> > &normal_vectors,
+ std::vector<double> &cell_JxW_values) const = 0;
/**
* Give class @p FEValues access
std::vector<Point<dim> > &quadrature_points,
std::vector<double> &JxW_values,
std::vector<Tensor<1,dim> > &boundary_form,
- std::vector<Point<dim> > &normal_vectors) const ;
+ std::vector<Point<dim> > &normal_vectors,
+ std::vector<double> &cell_JxW_values) const ;
virtual void
fill_fe_subface_values (const typename Triangulation<dim>::cell_iterator &cell,
const unsigned int face_no,
std::vector<Point<dim> > &quadrature_points,
std::vector<double> &JxW_values,
std::vector<Tensor<1,dim> > &boundary_form,
- std::vector<Point<dim> > &normal_vectors) const ;
+ std::vector<Point<dim> > &normal_vectors,
+ std::vector<double> &cell_JxW_values) const ;
/**
* Implementation of the
std::vector<Point<1> >&,
std::vector<double>&,
std::vector<Tensor<1,1> >&,
- std::vector<Point<1> >&) const;
+ std::vector<Point<1> >&,
+ std::vector<double>&) const;
template <> void MappingCartesian<1>::fill_fe_subface_values (
const Triangulation<1>::cell_iterator &,
std::vector<Point<1> >&,
std::vector<double>&,
std::vector<Tensor<1,1> >&,
- std::vector<Point<1> >&) const;
+ std::vector<Point<1> >&,
+ std::vector<double>&) const;
#endif // DOXYGEN
typename std::vector<Point<dim> > &quadrature_points,
std::vector<double> &JxW_values,
typename std::vector<Tensor<1,dim> > &exterior_form,
- typename std::vector<Point<dim> > &normal_vectors) const ;
+ typename std::vector<Point<dim> > &normal_vectors,
+ std::vector<double> &cell_JxW_values) const ;
/**
* Implementation of the interface in
typename std::vector<Point<dim> > &quadrature_points,
std::vector<double> &JxW_values,
typename std::vector<Tensor<1,dim> > &exterior_form,
- typename std::vector<Point<dim> > &normal_vectors) const ;
+ typename std::vector<Point<dim> > &normal_vectors,
+ std::vector<double> &cell_JxW_values) const ;
/**
* For <tt>dim=2,3</tt>. Append the
typename std::vector<Point<dim> > &quadrature_points,
std::vector<double> &JxW_values,
typename std::vector<Tensor<1,dim> > &boundary_form,
- typename std::vector<Point<dim> > &normal_vectors) const ;
+ typename std::vector<Point<dim> > &normal_vectors,
+ std::vector<double> &cell_JxW_values) const ;
/**
* Implementation of the interface in
typename std::vector<Point<dim> > &quadrature_points,
std::vector<double> &JxW_values,
typename std::vector<Tensor<1,dim> > &boundary_form,
- typename std::vector<Point<dim> > &normal_vectors) const ;
+ typename std::vector<Point<dim> > &normal_vectors,
+ std::vector<double> &cell_JxW_values) const ;
/**
* Compute shape values and/or
std::vector<Point<dim> > &quadrature_points,
std::vector<double> &JxW_values,
std::vector<Tensor<1,dim> > &boundary_form,
- std::vector<Point<dim> > &normal_vectors) const;
+ std::vector<Point<dim> > &normal_vectors,
+ std::vector<double> &cell_JxW_values) const;
/**
* Compute shape values and/or
std::vector<Point<1> > &,
std::vector<double> &,
std::vector<Tensor<1,1> > &,
- std::vector<Point<1> > &) const;
+ std::vector<Point<1> > &,
+ std::vector<double> &) const;
template <> void MappingQ1<1>::fill_fe_face_values (
const Triangulation<1>::cell_iterator &,
std::vector<Point<1> >&,
std::vector<double>&,
std::vector<Tensor<1,1> >&,
- std::vector<Point<1> >&) const;
+ std::vector<Point<1> >&,
+ std::vector<double>&) const;
template <> void MappingQ1<1>::fill_fe_subface_values (
const Triangulation<1>::cell_iterator &,
std::vector<Point<1> >&,
std::vector<double>&,
std::vector<Tensor<1,1> >&,
- std::vector<Point<1> >&) const;
+ std::vector<Point<1> >&,
+ std::vector<double>&) const;
#endif // DOXYGEN
* @p ith neighbor. If the
* neighbor does not exist, an
* invalid iterator is returned.
+ *
+ * <bf>Note</bf> (cf. TriaLevel<0>):
+ * The neighbor of a cell has at most the
+ * same level as this cell, i.e. it may
+ * or may not be refined.
*/
TriaIterator<dim,CellAccessor<dim> >
neighbor (const unsigned int i) const;
// that the other fine elements will
// be constrained to the coarse element.
{
- Assert (false, ExcNotImplemented ());
+ // Assert (false, ExcNotImplemented ());
typename DH::active_cell_iterator neighbor_child
= cell->neighbor_child_on_subface (face, min_degree_subface);
const unsigned int n_dofs_on_children = neighbor_child->get_fe().dofs_per_face;
dofs_on_children.resize (n_dofs_on_children);
+
+ // Get DoFs on child cell with
+ // lowest polynomial degree.
+ // All other DoFs will be constrained
+ // to the DoFs of this face.
+ const unsigned int subface_fe_index
+ = neighbor_child->active_fe_index();
+
+ // Same procedure as for the
+ // mother cell. Extract the face
+ // DoFs from the cell DoFs.
+ cell->face(face)->child(min_degree_subface)
+ ->get_dof_indices (dofs_on_children,
+ subface_fe_index);
+
+
// The idea is to introduce
// a "virtual" intermediate coarse
// level face with the lowest
// Now create the element
// constraint for this subface.
- FullMatrix<double> face_constraints_m (n_dofs_on_children,
- n_dofs_on_children);
+ FullMatrix<double> fc_sface_ipol (n_dofs_on_children,
+ n_dofs_on_children);
+ FullMatrix<double> fc_ipol_sface (n_dofs_on_children,
+ n_dofs_on_children);
neighbor_child->get_fe().get_subface_interpolation_matrix (neighbor_child->get_fe (),
min_degree_subface,
- face_constraints_m);
-//TODO: Continue ...
+ fc_sface_ipol);
+ // Invert it, to get a mapping from the DoFs of the
+ // "Master-subface" to the intermediate layer.
+ fc_ipol_sface.invert (fc_sface_ipol);
+
+ // Create constraint matrix for the mother face.
+ const unsigned int n_dofs_on_mother = cell->get_fe().dofs_per_face;
+ dofs_on_mother.resize (n_dofs_on_mother);
+ cell->face(face)->get_dof_indices (dofs_on_mother, cell->active_fe_index ());
+
+ FullMatrix<double> fc_mother_ipol (n_dofs_on_children,
+ n_dofs_on_mother);
+ FullMatrix<double> fc_mother_sface (n_dofs_on_children,
+ n_dofs_on_mother);
+ neighbor_child->get_fe ().get_face_interpolation_matrix (cell->get_fe(),
+ fc_mother_ipol);
+ fc_ipol_sface.mmult (fc_mother_sface, fc_mother_ipol);
+
+ // Add constraints to global constraint
+ // matrix.
+ filter_constraints (dofs_on_children,
+ dofs_on_mother,
+ fc_mother_sface,
+ constraints);
+
+ // Now create constraint matrices for
+ // the subfaces and assemble them
+ for (unsigned int c=0; c<GeometryInfo<dim>::subfaces_per_face; ++c)
+ {
+ // As the "Master-subface" does not need constraints, skip it.
+ if (c != min_degree_subface)
+ {
+ typename DH::active_cell_iterator neighbor_child_slave
+ = cell->neighbor_child_on_subface (face, c);
+ const unsigned int n_dofs_on_mother = neighbor_child_slave->get_fe().dofs_per_face;
+ dofs_on_mother.resize (n_dofs_on_mother);
+
+ // Find face number on the finer
+ // neighboring cell, which is
+ // shared the face with the
+ // face of the coarser cell.
+ const unsigned int neighbor2=
+ cell->neighbor_of_neighbor(face);
+ Assert (neighbor_child_slave->face(neighbor2) == cell->face(face)->child(c),
+ ExcInternalError());
+
+ // Same procedure as for the
+ // mother cell. Extract the face
+ // DoFs from the cell DoFs.
+ const unsigned int subface_fe_index
+ = neighbor_child_slave->active_fe_index();
+
+ cell->face(face)->child(c)
+ ->get_dof_indices (dofs_on_mother,
+ subface_fe_index);
+
+ // Now create the element
+ // constraint for this subface.
+ FullMatrix<double> fc_child_sface_ipol (n_dofs_on_children,
+ n_dofs_on_mother);
+ FullMatrix<double> fc_child_sface_sface (n_dofs_on_children,
+ n_dofs_on_mother);
+ neighbor_child->get_fe ().get_subface_interpolation_matrix
+ (neighbor_child_slave->get_fe(),
+ c, fc_child_sface_ipol);
+
+ fc_ipol_sface.mmult (fc_child_sface_sface, fc_child_sface_ipol);
+
+ // Add constraints to global constraint
+ // matrix.
+ filter_constraints (dofs_on_children,
+ dofs_on_mother,
+ fc_child_sface_sface,
+ constraints);
+ }
+ }
}
}
else
FullMatrix<double> M(n_dofs, n_dofs);
FETools::compute_node_matrix(M, *this);
- //TODO: Remove debugging output
- // M.print (std::cout);
-
this->inverse_node_matrix.reinit(n_dofs, n_dofs);
this->inverse_node_matrix.invert(M);
// From now on, the shape functions
if (flags & update_values)
out |= update_values | update_covariant_transformation
| update_contravariant_transformation
+ | update_cell_JxW_values
| update_JxW_values;
if (flags & update_gradients)
out |= update_gradients | update_covariant_transformation
| update_contravariant_transformation
+ | update_cell_JxW_values
| update_JxW_values;
//TODO: Set update flags appropriately and figure out, how the second
// derivatives for the RT elements can be computed correctly.
+//---------------------------------------------------------------------------
+// Utility method, which is used to determine the change of sign for
+// the DoFs on the faces of the given cell.
+//---------------------------------------------------------------------------
+
+template <class POLY, int dim>
+void
+FE_PolyTensor<POLY,dim>::get_face_sign_change (
+ const typename Triangulation<dim>::cell_iterator &cell,
+ std::vector<double> &face_sign) const
+{
+ Assert (face_sign.size () == this->dofs_per_cell,
+ ExcDimensionMismatch (face_sign.size (), this->dofs_per_cell));
+
+ // Default is no sign change. I.e. multiply by one.
+ std::fill (face_sign.begin (), face_sign.end (), 1.0);
+
+#if deal_II_dimension > 1
+ const unsigned int dofs_per_face = this->dofs_per_face;
+
+ if (dim == 2)
+ {
+ for (unsigned int f = GeometryInfo<dim>::faces_per_cell / 2;
+ f < GeometryInfo<dim>::faces_per_cell; ++f)
+ {
+ typename Triangulation<dim>::face_iterator face = cell->face (f);
+ if (!face->at_boundary ())
+ {
+ const unsigned int neighbor_level = cell->neighbor (f)->level ();
+ const unsigned int cell_level = cell->level ();
+
+ unsigned int nn = (unsigned int) -1;
+
+ // Same level, the easy case.
+ if (neighbor_level == cell_level)
+ nn = cell->neighbor_of_neighbor (f);
+ else
+ {
+ // Neighbor is more refined (due to the internal restrictions,
+ // this case should never be encountered!
+ if (neighbor_level > cell_level)
+ {
+ Assert (false,
+ ExcMessage ("neighbor_level is larger than cell level!"));
+ }
+ // Neighbor is less refined
+ else
+ nn = cell->neighbor_of_coarser_neighbor (f).first;
+ }
+
+ Assert (nn != (unsigned int) -1,
+ ExcInternalError ());
+
+ if (nn < GeometryInfo<dim>::faces_per_cell / 2)
+ {
+ for (unsigned int j = 0; j < dofs_per_face; ++j)
+ face_sign[f * dofs_per_face + j] = -1.0;
+ }
+ }
+ }
+ }
+ else
+ {
+ // TODO: Think about 3D!.
+ }
+#endif
+
+}
+
+
//---------------------------------------------------------------------------
// Data field initialization
//---------------------------------------------------------------------------
// Compute eventual sign changes depending on the neighborhood
// between two faces.
std::vector<double> sign_change (n_dofs, 1.0);
-
-#if deal_II_dimension > 1
- const unsigned int dofs_per_face = this->dofs_per_face;
-
- if (dim == 2)
- {
- for (unsigned int f = GeometryInfo<dim>::faces_per_cell / 2;
- f < GeometryInfo<dim>::faces_per_cell; ++f)
- {
- typename Triangulation<dim>::face_iterator face = cell->face (f);
- if (!face->at_boundary ())
- {
- unsigned int nn = cell->neighbor_of_neighbor (f);
- if (nn < GeometryInfo<dim>::faces_per_cell / 2)
- {
- for (unsigned int j = 0; j < dofs_per_face; ++j)
- sign_change[f * dofs_per_face + j] = -1.0;
- }
- }
- }
- }
- else
- {
- // TODO: Think about 3D!.
- }
-#endif
+ get_face_sign_change (cell, sign_change);
for (unsigned int i=0; i<n_dofs; ++i)
{
// Compute eventual sign changes depending on the neighborhood
// between two faces.
std::vector<double> sign_change (n_dofs, 1.0);
-#if deal_II_dimension > 1
- const unsigned int dofs_per_face = this->dofs_per_face;
-
- if (dim == 2)
- {
- for (unsigned int f = GeometryInfo<dim>::faces_per_cell / 2;
- f < GeometryInfo<dim>::faces_per_cell; ++f)
- {
- typename Triangulation<dim>::face_iterator face = cell->face (f);
- if (!face->at_boundary ())
- {
- unsigned int nn = cell->neighbor_of_neighbor (f);
- if (nn < GeometryInfo<dim>::faces_per_cell / 2)
- {
- for (unsigned int j = 0; j < dofs_per_face; ++j)
- sign_change[f * dofs_per_face + j] = -1.0;
- }
- }
- }
- }
- else
- {
- // TODO: Think about 3D!.
- }
-#endif
+ get_face_sign_change (cell, sign_change);
for (unsigned int i=0; i<n_dofs; ++i)
{
//TODO: Note that the Jacobian we compute here is that of the transformation from the reference FACE to the real FACE. However, what we need is the Jacobian of the transformation of the reference to the real CELL, which differs by one power of h. Consequently, the tests fe/rt_{11,13,14,15} presently compute the wrong results
double J = 1.0;
if (mapping_type == contravariant)
- J = data.JxW_values[k] / quadrature.weight(k);
+ J = data.cell_JxW_values[k] / quadrature.weight(k);
for (unsigned int d=0; d<dim; ++d)
data.shape_values(first+d,k) = sign_change[i] * (shape_values[k][d] / J);
{
// Recompute determinant
//TODO: Note that the Jacobian we compute here is that of the transformation from the reference FACE to the real FACE. However, what we need is the Jacobian of the transformation of the reference to the real CELL, which differs by one power of h. Consequently, the tests fe/rt_{11,13,14,15} presently compute the wrong results
- double J = data.JxW_values[k] / quadrature.weight(k);
+
+ double J = data.cell_JxW_values[k] / quadrature.weight(k);
data.shape_gradients[first+d][k] = sign_change[i] *
shape_grads2[k][d] / J;
}
// && dynamic_cast<const MappingCartesian<dim>*>(&mapping) != 0),
// ExcNotImplemented());
//TODO: Size assertions
+
+//TODO: Sign change for the face DoFs!
for (unsigned int i=0; i<n_dofs; ++i)
{
if (flags & update_values)
out |= update_values | update_covariant_transformation
| update_contravariant_transformation
+ | update_cell_JxW_values
| update_JxW_values;
if (flags & update_gradients)
out |= update_gradients | update_covariant_transformation
| update_contravariant_transformation
+ | update_cell_JxW_values
| update_JxW_values;
//TODO: Set update flags appropriately and figure out, how the second
// derivatives for the RT elements can be computed correctly.
// the reference element to the global
// coordinate system.
base_data.JxW_values = data.JxW_values;
+ base_data.cell_JxW_values = data.cell_JxW_values;
// Make sure that in the
if (flags & update_normal_vectors)
this->normal_vectors.resize(n_quadrature_points);
+
+ if (flags & update_cell_JxW_values)
+ this->cell_JxW_values.resize(n_quadrature_points);
}
MemoryConsumption::memory_consumption (this->quadrature_points) +
MemoryConsumption::memory_consumption (this->normal_vectors) +
MemoryConsumption::memory_consumption (this->boundary_forms) +
+ MemoryConsumption::memory_consumption (this->cell_JxW_values) +
sizeof(this->update_flags) +
MemoryConsumption::memory_consumption (n_quadrature_points) +
MemoryConsumption::memory_consumption (dofs_per_cell) +
this->quadrature_points,
this->JxW_values,
this->boundary_forms,
- this->normal_vectors);
+ this->normal_vectors,
+ this->cell_JxW_values);
this->get_fe().fill_fe_face_values(this->get_mapping(),
*this->present_cell, face_no,
this->quadrature_points,
this->JxW_values,
this->boundary_forms,
- this->normal_vectors);
+ this->normal_vectors,
+ this->cell_JxW_values);
this->get_fe().fill_fe_subface_values(this->get_mapping(),
*this->present_cell,
std::vector<Point<dim> > &quadrature_points,
std::vector<double> &JxW_values,
std::vector<Tensor<1,dim> > &boundary_forms,
- std::vector<Point<dim> > &normal_vectors) const
+ std::vector<Point<dim> > &normal_vectors,
+ std::vector<double> &/*cell_JxW_values*/) const
{
// convert data object to internal
// data for this class. fails with
if (data.current_update_flags() & update_boundary_forms)
for (unsigned int i=0; i<boundary_forms.size();++i)
boundary_forms[i] = J * normal_vectors[i];
+
+ //TODO: Implement cell_JxW_values
}
std::vector<Point<dim> > &quadrature_points,
std::vector<double> &JxW_values,
std::vector<Tensor<1,dim> > &boundary_forms,
- std::vector<Point<dim> > &normal_vectors) const
+ std::vector<Point<dim> > &normal_vectors,
+ std::vector<double> &/*cell_JxW_values*/) const
{
// convert data object to internal
// data for this class. fails with
if (data.current_update_flags() & update_boundary_forms)
for (unsigned int i=0; i<boundary_forms.size();++i)
boundary_forms[i] = J * normal_vectors[i];
+
+ //TODO: Implement cell_JxW_values
}
std::vector<Point<1> >&,
std::vector<double>&,
std::vector<Tensor<1,1> >&,
- std::vector<Point<1> >&) const
+ std::vector<Point<1> >&,
+ std::vector<double> &/*cell_JxW_values*/) const
{
Assert(false, ExcNotImplemented());
}
std::vector<Point<1> >&,
std::vector<double>&,
std::vector<Tensor<1,1> >&,
- std::vector<Point<1> >&) const
+ std::vector<Point<1> >&,
+ std::vector<double> &/*cell_JxW_values*/) const
{
Assert(false, ExcNotImplemented());
}
std::vector<Point<dim> > &quadrature_points,
std::vector<double> &JxW_values,
std::vector<Tensor<1,dim> > &exterior_forms,
- std::vector<Point<dim> > &normal_vectors) const
+ std::vector<Point<dim> > &normal_vectors,
+ std::vector<double> &cell_JxW_values) const
{
// convert data object to internal
// data for this class. fails with
q.get_weights(),
*p_data,
quadrature_points, JxW_values,
- exterior_forms, normal_vectors);
+ exterior_forms, normal_vectors,
+ cell_JxW_values);
+
+ // TODO: Verify implementation of cell_JxW_values
}
std::vector<Point<dim> > &quadrature_points,
std::vector<double> &JxW_values,
std::vector<Tensor<1,dim> > &exterior_forms,
- std::vector<Point<dim> > &normal_vectors) const
+ std::vector<Point<dim> > &normal_vectors,
+ std::vector<double> &cell_JxW_values) const
{
// convert data object to internal
// data for this class. fails with
q.get_weights(),
*p_data,
quadrature_points, JxW_values,
- exterior_forms, normal_vectors);
+ exterior_forms, normal_vectors,
+ cell_JxW_values);
+
+ // TODO: Verify implementation of cell_JxW_values ...
}
| update_covariant_transformation
| update_contravariant_transformation
| update_JxW_values
+ | update_cell_JxW_values
| update_boundary_forms
| update_normal_vectors));
| update_normal_vectors))
out |= update_contravariant_transformation;
+ // The contravariant transformation
+ // is a Piola transformation, which
+ // requires the determinant of the
+ // Jacobi matrix of the transformation.
+ // Therefore these values have to
+ // updated for each cell.
+ if (out & update_contravariant_transformation)
+ out |= update_JxW_values | update_cell_JxW_values;
+
return out;
}
std::vector<Point<dim> > &quadrature_points,
std::vector<double> &JxW_values,
std::vector<Tensor<1,dim> > &boundary_forms,
- std::vector<Point<dim> > &normal_vectors) const
+ std::vector<Point<dim> > &normal_vectors,
+ std::vector<double> &cell_JxW_values) const
{
compute_fill (cell, n_q_points, data_set, data, quadrature_points);
normal_vectors[i] = boundary_forms[i] / f;
}
}
+
+ // If the Piola transformation is to be used, the
+ // new flag, update_cell_JxW_values has to be set.
+ // It triggers the creation of values for the determinant
+ // of the mapping function on
+ if (update_flags & update_cell_JxW_values)
+ {
+ Assert (cell_JxW_values.size() == n_q_points,
+ ExcDimensionMismatch(cell_JxW_values.size(), n_q_points));
+ Assert (data.contravariant.size() == n_q_points,
+ ExcDimensionMismatch(data.contravariant.size(), n_q_points));
+ Assert (weights.size() == n_q_points,
+ ExcDimensionMismatch(weights.size(), n_q_points));
+ for (unsigned int point=0; point<n_q_points; ++point)
+ cell_JxW_values[point]
+ = determinant(data.contravariant[point])*weights[point];
+ }
}
std::vector<Point<dim> > &quadrature_points,
std::vector<double> &JxW_values,
std::vector<Tensor<1,dim> > &boundary_forms,
- std::vector<Point<dim> > &normal_vectors) const
+ std::vector<Point<dim> > &normal_vectors,
+ std::vector<double> &cell_JxW_values) const
{
InternalData *data_ptr = dynamic_cast<InternalData *> (&mapping_data);
Assert(data_ptr!=0, ExcInternalError());
quadrature_points,
JxW_values,
boundary_forms,
- normal_vectors);
+ normal_vectors,
+ cell_JxW_values);
}
std::vector<Point<dim> > &quadrature_points,
std::vector<double> &JxW_values,
std::vector<Tensor<1,dim> > &boundary_forms,
- std::vector<Point<dim> > &normal_vectors) const
+ std::vector<Point<dim> > &normal_vectors,
+ std::vector<double> &cell_JxW_values) const
{
InternalData *data_ptr = dynamic_cast<InternalData *> (&mapping_data);
Assert(data_ptr!=0, ExcInternalError());
quadrature_points,
JxW_values,
boundary_forms,
- normal_vectors);
+ normal_vectors,
+ cell_JxW_values);
}
std::vector<Point<1> > &,
std::vector<double> &,
std::vector<Tensor<1,1> > &,
- std::vector<Point<1> > &) const
+ std::vector<Point<1> > &,
+ std::vector<double> &/*cell_JxW_values*/) const
{
Assert(false, ExcNotImplemented());
}
std::vector<Point<1> >&,
std::vector<double>&,
std::vector<Tensor<1,1> >&,
- std::vector<Point<1> >&) const
+ std::vector<Point<1> >&,
+ std::vector<double> &/*cell_JxW_values*/) const
{
Assert(false, ExcNotImplemented());
}
std::vector<Point<1> >&,
std::vector<double>&,
std::vector<Tensor<1,1> >&,
- std::vector<Point<1> >&) const
+ std::vector<Point<1> >&,
+ std::vector<double> &/*cell_JxW_values*/) const
{
Assert(false, ExcNotImplemented());
}