* code that describes a finite element simply by providing a polynomial
* space (without having to give it any particular basis -- whatever is convenient
* is entirely sufficient) and the nodal functionals. This is used, for example
- * in the FiniteElement::convert_generalized_support_point_values_to_nodal_values()
+ * in the FiniteElement::convert_generalized_support_point_values_to_dof_values()
* function.
* </dd>
*
*/
virtual
void
- convert_generalized_support_point_values_to_nodal_values (const std::vector<Vector<double> > &support_point_values,
- std::vector<double> &nodal_values) const;
+ convert_generalized_support_point_values_to_dof_values (const std::vector<Vector<double> > &support_point_values,
+ std::vector<double> &nodal_values) const;
//@}
// documentation inherited from the base class
virtual
void
- convert_generalized_support_point_values_to_nodal_values (const std::vector<Vector<double> > &support_point_values,
- std::vector<double> &nodal_values) const;
+ convert_generalized_support_point_values_to_dof_values (const std::vector<Vector<double> > &support_point_values,
+ std::vector<double> &nodal_values) const;
virtual std::size_t memory_consumption () const;
// documentation inherited from the base class
virtual
void
- convert_generalized_support_point_values_to_nodal_values (const std::vector<Vector<double> > &support_point_values,
- std::vector<double> &nodal_values) const;
+ convert_generalized_support_point_values_to_dof_values (const std::vector<Vector<double> > &support_point_values,
+ std::vector<double> &nodal_values) const;
private:
/**
*/
virtual
void
- convert_generalized_support_point_values_to_nodal_values (const std::vector<Vector<double> > &support_point_values,
- std::vector<double> &nodal_values) const;
+ convert_generalized_support_point_values_to_dof_values (const std::vector<Vector<double> > &support_point_values,
+ std::vector<double> &nodal_values) const;
/**
* Determine an estimate for the memory consumption (in bytes) of this
*/
virtual
void
- convert_generalized_support_point_values_to_nodal_values (const std::vector<Vector<double> > &support_point_values,
- std::vector<double> &nodal_values) const;
+ convert_generalized_support_point_values_to_dof_values (const std::vector<Vector<double> > &support_point_values,
+ std::vector<double> &nodal_values) const;
virtual
std::unique_ptr<FiniteElement<dim,spacedim> >
clone() const;
// documentation inherited from the base class
virtual
void
- convert_generalized_support_point_values_to_nodal_values (const std::vector<Vector<double> > &support_point_values,
- std::vector<double> &nodal_values) const;
+ convert_generalized_support_point_values_to_dof_values (const std::vector<Vector<double> > &support_point_values,
+ std::vector<double> &nodal_values) const;
/**
* Return a list of constant modes of the element.
*/
virtual
void
- convert_generalized_support_point_values_to_nodal_values (const std::vector<Vector<double> > &support_point_values,
- std::vector<double> &nodal_values) const;
+ convert_generalized_support_point_values_to_dof_values (const std::vector<Vector<double> > &support_point_values,
+ std::vector<double> &nodal_values) const;
};
// documentation inherited from the base class
virtual
void
- convert_generalized_support_point_values_to_nodal_values (const std::vector<Vector<double> > &support_point_values,
- std::vector<double> &nodal_values) const;
+ convert_generalized_support_point_values_to_dof_values (const std::vector<Vector<double> > &support_point_values,
+ std::vector<double> &nodal_values) const;
/**
* Return the matrix interpolating from the given finite element to the
// documentation inherited from the base class
virtual
void
- convert_generalized_support_point_values_to_nodal_values (const std::vector<Vector<double> > &support_point_values,
- std::vector<double> &nodal_values) const;
+ convert_generalized_support_point_values_to_dof_values (const std::vector<Vector<double> > &support_point_values,
+ std::vector<double> &nodal_values) const;
/**
* Return the matrix interpolating from the given finite element to the
*/
virtual
void
- convert_generalized_support_point_values_to_nodal_values (const std::vector<Vector<double> > &support_point_values,
- std::vector<double> &nodal_values) const;
+ convert_generalized_support_point_values_to_dof_values (const std::vector<Vector<double> > &support_point_values,
+ std::vector<double> &nodal_values) const;
/**
* @name Functions to support hp
// documentation inherited from the base class
virtual
void
- convert_generalized_support_point_values_to_nodal_values (const std::vector<Vector<double> > &support_point_values,
- std::vector<double> &nodal_values) const;
+ convert_generalized_support_point_values_to_dof_values (const std::vector<Vector<double> > &support_point_values,
+ std::vector<double> &nodal_values) const;
private:
/**
// documentation inherited from the base class
virtual
void
- convert_generalized_support_point_values_to_nodal_values (const std::vector<Vector<double> > &support_point_values,
- std::vector<double> &nodal_values) const;
+ convert_generalized_support_point_values_to_dof_values (const std::vector<Vector<double> > &support_point_values,
+ std::vector<double> &nodal_values) const;
/**
* Return a list of constant modes of the element. This method is currently
virtual
void
- convert_generalized_support_point_values_to_nodal_values (const std::vector<Vector<double> > &support_point_values,
- std::vector<double> &nodal_values) const;
+ convert_generalized_support_point_values_to_dof_values (const std::vector<Vector<double> > &support_point_values,
+ std::vector<double> &nodal_values) const;
virtual void get_face_interpolation_matrix (const FiniteElement<dim> &source,
FullMatrix<double> &matrix) const;
/**
* Implementation of the
- * FiniteElement::convert_generalized_support_point_values_to_nodal_values()
+ * FiniteElement::convert_generalized_support_point_values_to_dof_values()
* function. The current function simply takes the input argument apart,
* passes the pieces to the base elements, and then re-assembles everything
* into the output argument.
*/
virtual
void
- convert_generalized_support_point_values_to_nodal_values (const std::vector<Vector<double> > &support_point_values,
- std::vector<double> &nodal_values) const;
+ convert_generalized_support_point_values_to_dof_values (const std::vector<Vector<double> > &support_point_values,
+ std::vector<double> &nodal_values) const;
/**
* Determine an estimate for the memory consumption (in bytes) of this
* that returns a scalar.
* - That the finite element has exactly @p dim vector components.
* - That the function $f_j$ is given by whatever the element implements
- * through the FiniteElement::convert_generalized_support_point_values_to_nodal_values()
+ * through the FiniteElement::convert_generalized_support_point_values_to_dof_values()
* function.
*
* @param fe The finite element for which the operations above are to be
template <int dim, int spacedim>
void
FiniteElement<dim,spacedim>::
-convert_generalized_support_point_values_to_nodal_values (const std::vector<Vector<double> > &,
- std::vector<double> &) const
+convert_generalized_support_point_values_to_dof_values (const std::vector<Vector<double> > &,
+ std::vector<double> &) const
{
Assert (has_generalized_support_points(),
ExcMessage ("The element for which you are calling the current "
template <int dim>
void
FE_ABF<dim>::
-convert_generalized_support_point_values_to_nodal_values (const std::vector<Vector<double> > &support_point_values,
- std::vector<double> &nodal_values) const
+convert_generalized_support_point_values_to_dof_values (const std::vector<Vector<double> > &support_point_values,
+ std::vector<double> &nodal_values) const
{
Assert (support_point_values.size() == this->generalized_support_points.size(),
ExcDimensionMismatch(support_point_values.size(), this->generalized_support_points.size()));
template <int dim>
void
FE_BDM<dim>::
-convert_generalized_support_point_values_to_nodal_values (const std::vector<Vector<double> > &support_point_values,
- std::vector<double> &nodal_values) const
+convert_generalized_support_point_values_to_dof_values (const std::vector<Vector<double> > &support_point_values,
+ std::vector<double> &nodal_values) const
{
Assert (support_point_values.size() == this->generalized_support_points.size(),
ExcDimensionMismatch(support_point_values.size(), this->generalized_support_points.size()));
template <int dim, int spacedim>
void
FE_DGQ<dim,spacedim>::
-convert_generalized_support_point_values_to_nodal_values (const std::vector<Vector<double> > &support_point_values,
- std::vector<double> &nodal_values) const
+convert_generalized_support_point_values_to_dof_values (const std::vector<Vector<double> > &support_point_values,
+ std::vector<double> &nodal_values) const
{
AssertDimension (support_point_values.size(),
this->get_unit_support_points().size());
template <int dim, int spacedim>
void
FE_DGQArbitraryNodes<dim,spacedim>::
-convert_generalized_support_point_values_to_nodal_values (const std::vector<Vector<double> > &support_point_values,
- std::vector<double> &nodal_values) const
+convert_generalized_support_point_values_to_dof_values (const std::vector<Vector<double> > &support_point_values,
+ std::vector<double> &nodal_values) const
{
AssertDimension (support_point_values.size(),
this->get_unit_support_points().size());
template <int dim>
void
FE_Nedelec<dim>::
-convert_generalized_support_point_values_to_nodal_values (const std::vector<Vector<double> > &support_point_values,
- std::vector<double> &nodal_values) const
+convert_generalized_support_point_values_to_dof_values (const std::vector<Vector<double> > &support_point_values,
+ std::vector<double> &nodal_values) const
{
const unsigned int deg = this->degree-1;
Assert (support_point_values.size () == this->generalized_support_points.size (),
template <int dim, int spacedim>
void
FE_Q<dim,spacedim>::
-convert_generalized_support_point_values_to_nodal_values (const std::vector<Vector<double> > &support_point_values,
- std::vector<double> &nodal_values) const
+convert_generalized_support_point_values_to_dof_values (const std::vector<Vector<double> > &support_point_values,
+ std::vector<double> &nodal_values) const
{
AssertDimension (support_point_values.size(),
this->get_unit_support_points().size());
template <int dim, int spacedim>
void
FE_Q_Bubbles<dim,spacedim>::
-convert_generalized_support_point_values_to_nodal_values(const std::vector<Vector<double> > &support_point_values,
- std::vector<double> &nodal_values) const
+convert_generalized_support_point_values_to_dof_values(const std::vector<Vector<double> > &support_point_values,
+ std::vector<double> &nodal_values) const
{
Assert (support_point_values.size() == this->unit_support_points.size(),
ExcDimensionMismatch(support_point_values.size(),
template <int dim, int spacedim>
void
FE_Q_DG0<dim,spacedim>::
-convert_generalized_support_point_values_to_nodal_values(const std::vector<Vector<double> > &support_point_values,
- std::vector<double> &nodal_dofs) const
+convert_generalized_support_point_values_to_dof_values(const std::vector<Vector<double> > &support_point_values,
+ std::vector<double> &nodal_dofs) const
{
Assert (support_point_values.size() == this->unit_support_points.size(),
ExcDimensionMismatch(support_point_values.size(),
template <int dim, int spacedim>
void
FE_Q_iso_Q1<dim,spacedim>::
-convert_generalized_support_point_values_to_nodal_values (const std::vector<Vector<double> > &support_point_values,
- std::vector<double> &nodal_values) const
+convert_generalized_support_point_values_to_dof_values (const std::vector<Vector<double> > &support_point_values,
+ std::vector<double> &nodal_values) const
{
AssertDimension (support_point_values.size(),
this->get_unit_support_points().size());
template <int dim>
void
FE_RannacherTurek<dim>::
-convert_generalized_support_point_values_to_nodal_values(const std::vector<Vector<double> > &support_point_values,
- std::vector<double> &nodal_values) const
+convert_generalized_support_point_values_to_dof_values(const std::vector<Vector<double> > &support_point_values,
+ std::vector<double> &nodal_values) const
{
AssertDimension(support_point_values.size(), this->generalized_support_points.size());
AssertDimension(nodal_values.size(), this->dofs_per_cell);
template <int dim>
void
FE_RaviartThomas<dim>::
-convert_generalized_support_point_values_to_nodal_values(const std::vector<Vector<double> > &support_point_values,
- std::vector<double> &nodal_values) const
+convert_generalized_support_point_values_to_dof_values(const std::vector<Vector<double> > &support_point_values,
+ std::vector<double> &nodal_values) const
{
Assert (support_point_values.size() == this->generalized_support_points.size(),
ExcDimensionMismatch(support_point_values.size(), this->generalized_support_points.size()));
template <int dim>
void
FE_RaviartThomasNodal<dim>::
-convert_generalized_support_point_values_to_nodal_values(const std::vector<Vector<double> > &support_point_values,
- std::vector<double> &nodal_values) const
+convert_generalized_support_point_values_to_dof_values(const std::vector<Vector<double> > &support_point_values,
+ std::vector<double> &nodal_values) const
{
Assert (support_point_values.size() == this->generalized_support_points.size(),
ExcDimensionMismatch(support_point_values.size(), this->generalized_support_points.size()));
template <int dim, int spacedim>
void
FESystem<dim,spacedim>::
-convert_generalized_support_point_values_to_nodal_values (const std::vector<Vector<double> > &support_point_values,
- std::vector<double> &nodal_values) const
+convert_generalized_support_point_values_to_dof_values (const std::vector<Vector<double> > &support_point_values,
+ std::vector<double> &nodal_values) const
{
// we currently only support the case where each base element has exactly
// as many generalized support points as there are dofs in that element.
// then call the base element to get its version of the
// nodal values
base_nodal_values.resize (base_element(base).dofs_per_cell);
- base_element(base).convert_generalized_support_point_values_to_nodal_values
+ base_element(base).convert_generalized_support_point_values_to_dof_values
(base_support_point_values, base_nodal_values);
// finally put these nodal values back into global nodal
Assert (numbers::is_finite(support_point_values[k][d]), ExcInternalError());
}
- fe.convert_generalized_support_point_values_to_nodal_values(support_point_values,
- nodal_values);
+ fe.convert_generalized_support_point_values_to_dof_values(support_point_values,
+ nodal_values);
// Enter the interpolated dofs into the matrix
for (unsigned int j=0; j<n_dofs; ++j)
-// Check that convert_generalized_support_point_values_to_nodal_values
+// Check that convert_generalized_support_point_values_to_dof_values
// gives the correct when asking for we the nodal values for a
// function in the FE_ABF<dim(degree) ansatz space.
real_values[i][c] += dof_values[j] * fe.shape_value_component(j, generalized_support_points[i], c);
std::vector<double> compare_values (fe.dofs_per_cell);
- fe.convert_generalized_support_point_values_to_nodal_values(real_values, compare_values);
+ fe.convert_generalized_support_point_values_to_dof_values(real_values, compare_values);
for (unsigned int i=0; i<dof_values.size(); ++i)
if (std::abs(dof_values[i]-compare_values[i]) > std::abs(dof_values[i])*1.e-6)
{
for (unsigned int k = 0; k < values.size(); ++k)
values[k][0] = fe.shape_value(i, points[k]);
- fe.convert_generalized_support_point_values_to_nodal_values(values, local_dofs);
+ fe.convert_generalized_support_point_values_to_dof_values(values, local_dofs);
for (unsigned int j=0; j < n_dofs; ++j)
N(j,i) = local_dofs[j];
fev.get_function_values(input_vector, values);
std::vector<double> interpolated_local_dofs(n_dofs);
- fe.convert_generalized_support_point_values_to_nodal_values(values, interpolated_local_dofs);
+ fe.convert_generalized_support_point_values_to_dof_values(values, interpolated_local_dofs);
Vector<double> local_dofs(n_dofs);
cell->get_dof_values(input_vector, local_dofs);
std::vector<Vector<double> > values (fe.get_unit_support_points().size(),
Vector<double>(1));
f.vector_value_list(fe.get_unit_support_points(), values);
- fe.convert_generalized_support_point_values_to_nodal_values(values, dofs);
+ fe.convert_generalized_support_point_values_to_dof_values(values, dofs);
deallog << " vector " << difference(fe,dofs,f) << std::endl;
}
std::vector<Vector<double> > values (fe.get_unit_support_points().size(),
Vector<double>(1));
f.vector_value_list(fe.get_unit_support_points(), values);
- fe.convert_generalized_support_point_values_to_nodal_values(values, dofs);
+ fe.convert_generalized_support_point_values_to_dof_values(values, dofs);
deallog << " vector " << difference(fe,dofs,f) << std::endl;
}
std::vector<Vector<double> > values (fe.get_unit_support_points().size(),
Vector<double>(1));
f.vector_value_list(fe.get_unit_support_points(), values);
- fe.convert_generalized_support_point_values_to_nodal_values(values, dofs);
+ fe.convert_generalized_support_point_values_to_dof_values(values, dofs);
deallog << " vector " << difference(fe,dofs,f) << std::endl;
}
std::vector<Vector<double> > values (fe.get_unit_support_points().size(),
Vector<double>(1));
f.vector_value_list(fe.get_unit_support_points(), values);
- fe.convert_generalized_support_point_values_to_nodal_values(values, dofs);
+ fe.convert_generalized_support_point_values_to_dof_values(values, dofs);
deallog << " value " << difference(fe,dofs,f) << std::endl;
}
std::vector<Vector<double> > values (fe.get_unit_support_points().size(),
Vector<double>(1));
f.vector_value_list(fe.get_unit_support_points(), values);
- fe.convert_generalized_support_point_values_to_nodal_values(values, dofs);
+ fe.convert_generalized_support_point_values_to_dof_values(values, dofs);
deallog << " vector " << difference(fe,dofs,f) << std::endl;
}
std::vector<Vector<double> > values (fe.get_unit_support_points().size(),
Vector<double>(1));
f.vector_value_list(fe.get_unit_support_points(), values);
- fe.convert_generalized_support_point_values_to_nodal_values(values, dofs);
+ fe.convert_generalized_support_point_values_to_dof_values(values, dofs);
deallog << " vector " << difference(fe,dofs,f) << std::endl;
}
std::vector<Vector<double> > values (fe.get_generalized_support_points().size(),
Vector<double>(dim));
f.vector_value_list(fe.get_generalized_support_points(), values);
- fe.convert_generalized_support_point_values_to_nodal_values(values, dofs);
+ fe.convert_generalized_support_point_values_to_dof_values(values, dofs);
deallog << " vector " << vector_difference(fe,dofs,f,0) << std::endl;
}
std::vector<Vector<double> > values (fe.get_generalized_support_points().size(),
Vector<double>(dim));
f.vector_value_list(fe.get_generalized_support_points(), values);
- fe.convert_generalized_support_point_values_to_nodal_values(values, dofs);
+ fe.convert_generalized_support_point_values_to_dof_values(values, dofs);
deallog << " vector " << vector_difference(fe,dofs,f,0) << std::endl;
}
std::vector<Vector<double> > values (fe.get_unit_support_points().size(),
Vector<double>(comp));
f.vector_value_list(fe.get_unit_support_points(), values);
- fe.convert_generalized_support_point_values_to_nodal_values(values, dofs);
+ fe.convert_generalized_support_point_values_to_dof_values(values, dofs);
deallog << " vector " << vector_difference(fe,dofs,f,0) << std::endl;
}
std::vector<Vector<double> > values (fe.get_unit_support_points().size(),
Vector<double>(f.n_components));
f.vector_value_list(fe.get_unit_support_points(), values);
- fe.convert_generalized_support_point_values_to_nodal_values(values, dofs);
+ fe.convert_generalized_support_point_values_to_dof_values(values, dofs);
deallog << " vector " << vector_difference(fe,dofs,f,0) << std::endl;
}