* cell in the mesh as reported by
* parallel::distributed::Triangulation::n_locally_owned_active_cells().
*/
- template <typename InputVector>
+ template <typename Number>
static void
estimate(
const Mapping<dim, spacedim> & mapping,
const DoFHandler<dim, spacedim> &dof,
const Quadrature<dim - 1> & quadrature,
- const std::map<types::boundary_id,
- const Function<spacedim, typename InputVector::value_type> *>
+ const std::map<types::boundary_id, const Function<spacedim, Number> *>
& neumann_bc,
- const InputVector & solution,
+ const ReadVector<Number> &solution,
Vector<float> & error,
const ComponentMask & component_mask = ComponentMask(),
const Function<spacedim> *coefficients = nullptr,
* Call the @p estimate function, see above, with
* <tt>mapping=MappingQ@<dim@>(1)</tt>.
*/
- template <typename InputVector>
+ template <typename Number>
static void
estimate(
const DoFHandler<dim, spacedim> &dof,
const Quadrature<dim - 1> & quadrature,
- const std::map<types::boundary_id,
- const Function<spacedim, typename InputVector::value_type> *>
+ const std::map<types::boundary_id, const Function<spacedim, Number> *>
& neumann_bc,
- const InputVector & solution,
+ const ReadVector<Number> &solution,
Vector<float> & error,
const ComponentMask & component_mask = ComponentMask(),
const Function<spacedim> *coefficients = nullptr,
* construct of vector of references, so we had to use a vector of
* pointers.)
*/
- template <typename InputVector>
+ template <typename Number>
static void
estimate(
const Mapping<dim, spacedim> & mapping,
const DoFHandler<dim, spacedim> &dof,
const Quadrature<dim - 1> & quadrature,
- const std::map<types::boundary_id,
- const Function<spacedim, typename InputVector::value_type> *>
- & neumann_bc,
- const std::vector<const InputVector *> &solutions,
- std::vector<Vector<float> *> & errors,
- const ComponentMask & component_mask = ComponentMask(),
- const Function<spacedim> * coefficients = nullptr,
- const unsigned int n_threads = numbers::invalid_unsigned_int,
- const types::subdomain_id subdomain_id = numbers::invalid_subdomain_id,
- const types::material_id material_id = numbers::invalid_material_id,
- const Strategy strategy = cell_diameter_over_24);
+ const std::map<types::boundary_id, const Function<spacedim, Number> *>
+ & neumann_bc,
+ const std::vector<const ReadVector<Number> *> &solutions,
+ std::vector<Vector<float> *> & errors,
+ const ComponentMask & component_mask = ComponentMask(),
+ const Function<spacedim> *coefficients = nullptr,
+ const unsigned int n_threads = numbers::invalid_unsigned_int,
+ const types::subdomain_id subdomain_id = numbers::invalid_subdomain_id,
+ const types::material_id material_id = numbers::invalid_material_id,
+ const Strategy strategy = cell_diameter_over_24);
/**
* Call the @p estimate function, see above, with
* <tt>mapping=MappingQ@<dim@>(1)</tt>.
*/
- template <typename InputVector>
+ template <typename Number>
static void
estimate(
const DoFHandler<dim, spacedim> &dof,
const Quadrature<dim - 1> & quadrature,
- const std::map<types::boundary_id,
- const Function<spacedim, typename InputVector::value_type> *>
- & neumann_bc,
- const std::vector<const InputVector *> &solutions,
- std::vector<Vector<float> *> & errors,
- const ComponentMask & component_mask = ComponentMask(),
- const Function<spacedim> * coefficients = nullptr,
- const unsigned int n_threads = numbers::invalid_unsigned_int,
- const types::subdomain_id subdomain_id = numbers::invalid_subdomain_id,
- const types::material_id material_id = numbers::invalid_material_id,
- const Strategy strategy = cell_diameter_over_24);
+ const std::map<types::boundary_id, const Function<spacedim, Number> *>
+ & neumann_bc,
+ const std::vector<const ReadVector<Number> *> &solutions,
+ std::vector<Vector<float> *> & errors,
+ const ComponentMask & component_mask = ComponentMask(),
+ const Function<spacedim> *coefficients = nullptr,
+ const unsigned int n_threads = numbers::invalid_unsigned_int,
+ const types::subdomain_id subdomain_id = numbers::invalid_subdomain_id,
+ const types::material_id material_id = numbers::invalid_material_id,
+ const Strategy strategy = cell_diameter_over_24);
/**
* Equivalent to the set of functions above, except that this one takes a
* quadrature collection for hp-finite element dof handlers.
*/
- template <typename InputVector>
+ template <typename Number>
static void
estimate(
const Mapping<dim, spacedim> & mapping,
const DoFHandler<dim, spacedim> &dof,
const hp::QCollection<dim - 1> & quadrature,
- const std::map<types::boundary_id,
- const Function<spacedim, typename InputVector::value_type> *>
+ const std::map<types::boundary_id, const Function<spacedim, Number> *>
& neumann_bc,
- const InputVector & solution,
+ const ReadVector<Number> &solution,
Vector<float> & error,
const ComponentMask & component_mask = ComponentMask(),
const Function<spacedim> *coefficients = nullptr,
* Equivalent to the set of functions above, except that this one takes a
* quadrature collection for hp-finite element dof handlers.
*/
- template <typename InputVector>
+ template <typename Number>
static void
estimate(
const DoFHandler<dim, spacedim> &dof,
const hp::QCollection<dim - 1> & quadrature,
- const std::map<types::boundary_id,
- const Function<spacedim, typename InputVector::value_type> *>
+ const std::map<types::boundary_id, const Function<spacedim, Number> *>
& neumann_bc,
- const InputVector & solution,
+ const ReadVector<Number> &solution,
Vector<float> & error,
const ComponentMask & component_mask = ComponentMask(),
const Function<spacedim> *coefficients = nullptr,
* Equivalent to the set of functions above, except that this one takes a
* quadrature collection for hp-finite element dof handlers.
*/
- template <typename InputVector>
+ template <typename Number>
static void
estimate(
const Mapping<dim, spacedim> & mapping,
const DoFHandler<dim, spacedim> &dof,
const hp::QCollection<dim - 1> & quadrature,
- const std::map<types::boundary_id,
- const Function<spacedim, typename InputVector::value_type> *>
- & neumann_bc,
- const std::vector<const InputVector *> &solutions,
- std::vector<Vector<float> *> & errors,
- const ComponentMask & component_mask = ComponentMask(),
- const Function<spacedim> * coefficients = nullptr,
- const unsigned int n_threads = numbers::invalid_unsigned_int,
- const types::subdomain_id subdomain_id = numbers::invalid_subdomain_id,
- const types::material_id material_id = numbers::invalid_material_id,
- const Strategy strategy = cell_diameter_over_24);
+ const std::map<types::boundary_id, const Function<spacedim, Number> *>
+ & neumann_bc,
+ const std::vector<const ReadVector<Number> *> &solutions,
+ std::vector<Vector<float> *> & errors,
+ const ComponentMask & component_mask = ComponentMask(),
+ const Function<spacedim> *coefficients = nullptr,
+ const unsigned int n_threads = numbers::invalid_unsigned_int,
+ const types::subdomain_id subdomain_id = numbers::invalid_subdomain_id,
+ const types::material_id material_id = numbers::invalid_material_id,
+ const Strategy strategy = cell_diameter_over_24);
/**
* Equivalent to the set of functions above, except that this one takes a
* quadrature collection for hp-finite element dof handlers.
*/
- template <typename InputVector>
+ template <typename Number>
static void
estimate(
const DoFHandler<dim, spacedim> &dof,
const hp::QCollection<dim - 1> & quadrature,
- const std::map<types::boundary_id,
- const Function<spacedim, typename InputVector::value_type> *>
- & neumann_bc,
- const std::vector<const InputVector *> &solutions,
- std::vector<Vector<float> *> & errors,
- const ComponentMask & component_mask = ComponentMask(),
- const Function<spacedim> * coefficients = nullptr,
- const unsigned int n_threads = numbers::invalid_unsigned_int,
- const types::subdomain_id subdomain_id = numbers::invalid_subdomain_id,
- const types::material_id material_id = numbers::invalid_material_id,
- const Strategy strategy = cell_diameter_over_24);
+ const std::map<types::boundary_id, const Function<spacedim, Number> *>
+ & neumann_bc,
+ const std::vector<const ReadVector<Number> *> &solutions,
+ std::vector<Vector<float> *> & errors,
+ const ComponentMask & component_mask = ComponentMask(),
+ const Function<spacedim> *coefficients = nullptr,
+ const unsigned int n_threads = numbers::invalid_unsigned_int,
+ const types::subdomain_id subdomain_id = numbers::invalid_subdomain_id,
+ const types::material_id material_id = numbers::invalid_material_id,
+ const Strategy strategy = cell_diameter_over_24);
/**
* Exception
* respective parameter for compatibility with the function signature in the
* general case.
*/
- template <typename InputVector>
+ template <typename Number>
static void
estimate(
const Mapping<1, spacedim> & mapping,
const DoFHandler<1, spacedim> &dof,
const Quadrature<0> & quadrature,
- const std::map<types::boundary_id,
- const Function<spacedim, typename InputVector::value_type> *>
+ const std::map<types::boundary_id, const Function<spacedim, Number> *>
& neumann_bc,
- const InputVector & solution,
+ const ReadVector<Number> &solution,
Vector<float> & error,
const ComponentMask & component_mask = ComponentMask(),
const Function<spacedim> *coefficient = nullptr,
* Call the @p estimate function, see above, with
* <tt>mapping=MappingQ1<1>()</tt>.
*/
- template <typename InputVector>
+ template <typename Number>
static void
estimate(
const DoFHandler<1, spacedim> &dof,
const Quadrature<0> & quadrature,
- const std::map<types::boundary_id,
- const Function<spacedim, typename InputVector::value_type> *>
+ const std::map<types::boundary_id, const Function<spacedim, Number> *>
& neumann_bc,
- const InputVector & solution,
+ const ReadVector<Number> &solution,
Vector<float> & error,
const ComponentMask & component_mask = ComponentMask(),
const Function<spacedim> *coefficients = nullptr,
* construct of vector of references, so we had to use a vector of
* pointers.)
*/
- template <typename InputVector>
+ template <typename Number>
static void
estimate(
const Mapping<1, spacedim> & mapping,
const DoFHandler<1, spacedim> &dof,
const Quadrature<0> & quadrature,
- const std::map<types::boundary_id,
- const Function<spacedim, typename InputVector::value_type> *>
- & neumann_bc,
- const std::vector<const InputVector *> &solutions,
- std::vector<Vector<float> *> & errors,
- const ComponentMask & component_mask = ComponentMask(),
- const Function<spacedim> * coefficients = nullptr,
- const unsigned int n_threads = numbers::invalid_unsigned_int,
- const types::subdomain_id subdomain_id = numbers::invalid_subdomain_id,
- const types::material_id material_id = numbers::invalid_material_id,
- const Strategy strategy = cell_diameter_over_24);
+ const std::map<types::boundary_id, const Function<spacedim, Number> *>
+ & neumann_bc,
+ const std::vector<const ReadVector<Number> *> &solutions,
+ std::vector<Vector<float> *> & errors,
+ const ComponentMask & component_mask = ComponentMask(),
+ const Function<spacedim> *coefficients = nullptr,
+ const unsigned int n_threads = numbers::invalid_unsigned_int,
+ const types::subdomain_id subdomain_id = numbers::invalid_subdomain_id,
+ const types::material_id material_id = numbers::invalid_material_id,
+ const Strategy strategy = cell_diameter_over_24);
* Call the @p estimate function, see above, with
* <tt>mapping=MappingQ1<1>()</tt>.
*/
- template <typename InputVector>
+ template <typename Number>
static void
estimate(
const DoFHandler<1, spacedim> &dof,
const Quadrature<0> & quadrature,
- const std::map<types::boundary_id,
- const Function<spacedim, typename InputVector::value_type> *>
- & neumann_bc,
- const std::vector<const InputVector *> &solutions,
- std::vector<Vector<float> *> & errors,
- const ComponentMask & component_mask = ComponentMask(),
- const Function<spacedim> * coefficients = nullptr,
- const unsigned int n_threads = numbers::invalid_unsigned_int,
- const types::subdomain_id subdomain_id = numbers::invalid_subdomain_id,
- const types::material_id material_id = numbers::invalid_material_id,
- const Strategy strategy = cell_diameter_over_24);
+ const std::map<types::boundary_id, const Function<spacedim, Number> *>
+ & neumann_bc,
+ const std::vector<const ReadVector<Number> *> &solutions,
+ std::vector<Vector<float> *> & errors,
+ const ComponentMask & component_mask = ComponentMask(),
+ const Function<spacedim> *coefficients = nullptr,
+ const unsigned int n_threads = numbers::invalid_unsigned_int,
+ const types::subdomain_id subdomain_id = numbers::invalid_subdomain_id,
+ const types::material_id material_id = numbers::invalid_material_id,
+ const Strategy strategy = cell_diameter_over_24);
* Equivalent to the set of functions above, except that this one takes a
* quadrature collection for hp-finite element dof handlers.
*/
- template <typename InputVector>
+ template <typename Number>
static void
estimate(
const Mapping<1, spacedim> & mapping,
const DoFHandler<1, spacedim> &dof,
const hp::QCollection<0> & quadrature,
- const std::map<types::boundary_id,
- const Function<spacedim, typename InputVector::value_type> *>
+ const std::map<types::boundary_id, const Function<spacedim, Number> *>
& neumann_bc,
- const InputVector & solution,
+ const ReadVector<Number> &solution,
Vector<float> & error,
const ComponentMask & component_mask = ComponentMask(),
const Function<spacedim> *coefficients = nullptr,
* Equivalent to the set of functions above, except that this one takes a
* quadrature collection for hp-finite element dof handlers.
*/
- template <typename InputVector>
+ template <typename Number>
static void
estimate(
const DoFHandler<1, spacedim> &dof,
const hp::QCollection<0> & quadrature,
- const std::map<types::boundary_id,
- const Function<spacedim, typename InputVector::value_type> *>
+ const std::map<types::boundary_id, const Function<spacedim, Number> *>
& neumann_bc,
- const InputVector & solution,
+ const ReadVector<Number> &solution,
Vector<float> & error,
const ComponentMask & component_mask = ComponentMask(),
const Function<spacedim> *coefficients = nullptr,
* Equivalent to the set of functions above, except that this one takes a
* quadrature collection for hp-finite element dof handlers.
*/
- template <typename InputVector>
+ template <typename Number>
static void
estimate(
const Mapping<1, spacedim> & mapping,
const DoFHandler<1, spacedim> &dof,
const hp::QCollection<0> & quadrature,
- const std::map<types::boundary_id,
- const Function<spacedim, typename InputVector::value_type> *>
- & neumann_bc,
- const std::vector<const InputVector *> &solutions,
- std::vector<Vector<float> *> & errors,
- const ComponentMask & component_mask = ComponentMask(),
- const Function<spacedim> * coefficients = nullptr,
- const unsigned int n_threads = numbers::invalid_unsigned_int,
- const types::subdomain_id subdomain_id = numbers::invalid_subdomain_id,
- const types::material_id material_id = numbers::invalid_material_id,
- const Strategy strategy = cell_diameter_over_24);
+ const std::map<types::boundary_id, const Function<spacedim, Number> *>
+ & neumann_bc,
+ const std::vector<const ReadVector<Number> *> &solutions,
+ std::vector<Vector<float> *> & errors,
+ const ComponentMask & component_mask = ComponentMask(),
+ const Function<spacedim> *coefficients = nullptr,
+ const unsigned int n_threads = numbers::invalid_unsigned_int,
+ const types::subdomain_id subdomain_id = numbers::invalid_subdomain_id,
+ const types::material_id material_id = numbers::invalid_material_id,
+ const Strategy strategy = cell_diameter_over_24);
* Equivalent to the set of functions above, except that this one takes a
* quadrature collection for hp-finite element dof handlers.
*/
- template <typename InputVector>
+ template <typename Number>
static void
estimate(
const DoFHandler<1, spacedim> &dof,
const hp::QCollection<0> & quadrature,
- const std::map<types::boundary_id,
- const Function<spacedim, typename InputVector::value_type> *>
- & neumann_bc,
- const std::vector<const InputVector *> &solutions,
- std::vector<Vector<float> *> & errors,
- const ComponentMask & component_mask = ComponentMask(),
- const Function<spacedim> * coefficients = nullptr,
- const unsigned int n_threads = numbers::invalid_unsigned_int,
- const types::subdomain_id subdomain_id = numbers::invalid_subdomain_id,
- const types::material_id material_id = numbers::invalid_material_id,
- const Strategy strategy = cell_diameter_over_24);
+ const std::map<types::boundary_id, const Function<spacedim, Number> *>
+ & neumann_bc,
+ const std::vector<const ReadVector<Number> *> &solutions,
+ std::vector<Vector<float> *> & errors,
+ const ComponentMask & component_mask = ComponentMask(),
+ const Function<spacedim> *coefficients = nullptr,
+ const unsigned int n_threads = numbers::invalid_unsigned_int,
+ const types::subdomain_id subdomain_id = numbers::invalid_subdomain_id,
+ const types::material_id material_id = numbers::invalid_material_id,
+ const Strategy strategy = cell_diameter_over_24);
* boundary), or the other side's refinement level is the same as that of
* this side, then handle the integration of these both cases together.
*/
- template <typename InputVector, int dim, int spacedim>
+ template <typename Number, int dim, int spacedim>
void
integrate_over_regular_face(
- const std::vector<const InputVector *> &solutions,
- ParallelData<dim, spacedim, typename InputVector::value_type>
- & parallel_data,
+ const std::vector<const ReadVector<Number> *> &solutions,
+ ParallelData<dim, spacedim, Number> & parallel_data,
std::map<typename DoFHandler<dim, spacedim>::face_iterator,
- std::vector<double>> &local_face_integrals,
+ std::vector<double>> & local_face_integrals,
const typename DoFHandler<dim, spacedim>::active_cell_iterator &cell,
const unsigned int face_no,
dealii::hp::FEFaceValues<dim, spacedim> &fe_face_values_cell,
* over face @p face_no of @p cell, where the respective neighbor is
* refined, so that the integration is a bit more complex.
*/
- template <typename InputVector, int dim, int spacedim>
+ template <typename Number, int dim, int spacedim>
void
integrate_over_irregular_face(
- const std::vector<const InputVector *> &solutions,
- ParallelData<dim, spacedim, typename InputVector::value_type>
- & parallel_data,
+ const std::vector<const ReadVector<Number> *> &solutions,
+ ParallelData<dim, spacedim, Number> & parallel_data,
std::map<typename DoFHandler<dim, spacedim>::face_iterator,
- std::vector<double>> &local_face_integrals,
+ std::vector<double>> & local_face_integrals,
const typename DoFHandler<dim, spacedim>::active_cell_iterator &cell,
const unsigned int face_no,
dealii::hp::FEFaceValues<dim, spacedim> & fe_face_values,
* This function is only needed in two or three dimensions. The error
* estimator in one dimension is implemented separately.
*/
- template <typename InputVector, int dim, int spacedim>
+ template <typename Number, int dim, int spacedim>
void
estimate_one_cell(
const typename DoFHandler<dim, spacedim>::active_cell_iterator &cell,
- ParallelData<dim, spacedim, typename InputVector::value_type>
- & parallel_data,
+ ParallelData<dim, spacedim, Number> & parallel_data,
std::map<typename DoFHandler<dim, spacedim>::face_iterator,
- std::vector<double>> & local_face_integrals,
- const std::vector<const InputVector *> &solutions,
+ std::vector<double>> & local_face_integrals,
+ const std::vector<const ReadVector<Number> *> &solutions,
const typename KellyErrorEstimator<dim, spacedim>::Strategy strategy)
{
const unsigned int n_solution_vectors = solutions.size();
// the following function is still independent of dimension, but it
// calls dimension dependent functions
template <int dim, int spacedim>
-template <typename InputVector>
+template <typename Number>
void
KellyErrorEstimator<dim, spacedim>::estimate(
const Mapping<dim, spacedim> & mapping,
const DoFHandler<dim, spacedim> &dof_handler,
const Quadrature<dim - 1> & quadrature,
- const std::map<types::boundary_id,
- const Function<spacedim, typename InputVector::value_type> *>
+ const std::map<types::boundary_id, const Function<spacedim, Number> *>
& neumann_bc,
- const InputVector & solution,
+ const ReadVector<Number> &solution,
Vector<float> & error,
const ComponentMask & component_mask,
const Function<spacedim> *coefficients,
const Strategy strategy)
{
// just pass on to the other function
- const std::vector<const InputVector *> solutions(1, &solution);
- std::vector<Vector<float> *> errors(1, &error);
+ const std::vector<const ReadVector<Number> *> solutions(1, &solution);
+ std::vector<Vector<float> *> errors(1, &error);
estimate(mapping,
dof_handler,
quadrature,
template <int dim, int spacedim>
-template <typename InputVector>
+template <typename Number>
void
KellyErrorEstimator<dim, spacedim>::estimate(
const DoFHandler<dim, spacedim> &dof_handler,
const Quadrature<dim - 1> & quadrature,
- const std::map<types::boundary_id,
- const Function<spacedim, typename InputVector::value_type> *>
+ const std::map<types::boundary_id, const Function<spacedim, Number> *>
& neumann_bc,
- const InputVector & solution,
+ const ReadVector<Number> &solution,
Vector<float> & error,
const ComponentMask & component_mask,
const Function<spacedim> *coefficients,
template <int dim, int spacedim>
-template <typename InputVector>
+template <typename Number>
void
KellyErrorEstimator<dim, spacedim>::estimate(
const Mapping<dim, spacedim> & mapping,
const DoFHandler<dim, spacedim> &dof_handler,
const hp::QCollection<dim - 1> & quadrature,
- const std::map<types::boundary_id,
- const Function<spacedim, typename InputVector::value_type> *>
+ const std::map<types::boundary_id, const Function<spacedim, Number> *>
& neumann_bc,
- const InputVector & solution,
+ const ReadVector<Number> &solution,
Vector<float> & error,
const ComponentMask & component_mask,
const Function<spacedim> *coefficients,
const Strategy strategy)
{
// just pass on to the other function
- const std::vector<const InputVector *> solutions(1, &solution);
- std::vector<Vector<float> *> errors(1, &error);
+ const std::vector<const ReadVector<Number> *> solutions(1, &solution);
+ std::vector<Vector<float> *> errors(1, &error);
estimate(mapping,
dof_handler,
quadrature,
template <int dim, int spacedim>
-template <typename InputVector>
+template <typename Number>
void
KellyErrorEstimator<dim, spacedim>::estimate(
const DoFHandler<dim, spacedim> &dof_handler,
const hp::QCollection<dim - 1> & quadrature,
- const std::map<types::boundary_id,
- const Function<spacedim, typename InputVector::value_type> *>
+ const std::map<types::boundary_id, const Function<spacedim, Number> *>
& neumann_bc,
- const InputVector & solution,
+ const ReadVector<Number> &solution,
Vector<float> & error,
const ComponentMask & component_mask,
const Function<spacedim> *coefficients,
template <int dim, int spacedim>
-template <typename InputVector>
+template <typename Number>
void
KellyErrorEstimator<dim, spacedim>::estimate(
const Mapping<dim, spacedim> & mapping,
const DoFHandler<dim, spacedim> &dof_handler,
const hp::QCollection<dim - 1> & face_quadratures,
- const std::map<types::boundary_id,
- const Function<spacedim, typename InputVector::value_type> *>
- & neumann_bc,
- const std::vector<const InputVector *> &solutions,
- std::vector<Vector<float> *> & errors,
- const ComponentMask & component_mask,
- const Function<spacedim> * coefficients,
+ const std::map<types::boundary_id, const Function<spacedim, Number> *>
+ & neumann_bc,
+ const std::vector<const ReadVector<Number> *> &solutions,
+ std::vector<Vector<float> *> & errors,
+ const ComponentMask & component_mask,
+ const Function<spacedim> * coefficients,
const unsigned int,
const types::subdomain_id subdomain_id_,
const types::material_id material_id,
// all the data needed in the error estimator by each of the threads is
// gathered in the following structures
const hp::MappingCollection<dim, spacedim> mapping_collection(mapping);
- const internal::ParallelData<dim, spacedim, typename InputVector::value_type>
- parallel_data(dof_handler.get_fe_collection(),
- face_quadratures,
- mapping_collection,
- (!neumann_bc.empty() || (coefficients != nullptr)),
- solutions.size(),
- subdomain_id,
- material_id,
- &neumann_bc,
- component_mask,
- coefficients);
+ const internal::ParallelData<dim, spacedim, Number> parallel_data(
+ dof_handler.get_fe_collection(),
+ face_quadratures,
+ mapping_collection,
+ (!neumann_bc.empty() || (coefficients != nullptr)),
+ solutions.size(),
+ subdomain_id,
+ material_id,
+ &neumann_bc,
+ component_mask,
+ coefficients);
std::map<typename DoFHandler<dim, spacedim>::face_iterator,
std::vector<double>>
sample_local_face_integrals;
dof_handler.end()),
[&solutions, strategy](
const typename DoFHandler<dim, spacedim>::active_cell_iterator &cell,
- internal::ParallelData<dim, spacedim, typename InputVector::value_type>
- & parallel_data,
+ internal::ParallelData<dim, spacedim, Number> ¶llel_data,
std::map<typename DoFHandler<dim, spacedim>::face_iterator,
- std::vector<double>> &local_face_integrals) {
+ std::vector<double>> & local_face_integrals) {
internal::estimate_one_cell(
cell, parallel_data, local_face_integrals, solutions, strategy);
},
template <int dim, int spacedim>
-template <typename InputVector>
+template <typename Number>
void
KellyErrorEstimator<dim, spacedim>::estimate(
const Mapping<dim, spacedim> & mapping,
const DoFHandler<dim, spacedim> &dof_handler,
const Quadrature<dim - 1> & quadrature,
- const std::map<types::boundary_id,
- const Function<spacedim, typename InputVector::value_type> *>
- & neumann_bc,
- const std::vector<const InputVector *> &solutions,
- std::vector<Vector<float> *> & errors,
- const ComponentMask & component_mask,
- const Function<spacedim> * coefficients,
- const unsigned int n_threads,
- const types::subdomain_id subdomain_id,
- const types::material_id material_id,
- const Strategy strategy)
+ const std::map<types::boundary_id, const Function<spacedim, Number> *>
+ & neumann_bc,
+ const std::vector<const ReadVector<Number> *> &solutions,
+ std::vector<Vector<float> *> & errors,
+ const ComponentMask & component_mask,
+ const Function<spacedim> * coefficients,
+ const unsigned int n_threads,
+ const types::subdomain_id subdomain_id,
+ const types::material_id material_id,
+ const Strategy strategy)
{
// forward to the function with the QCollection
estimate(mapping,
template <int dim, int spacedim>
-template <typename InputVector>
+template <typename Number>
void
KellyErrorEstimator<dim, spacedim>::estimate(
const DoFHandler<dim, spacedim> &dof_handler,
const Quadrature<dim - 1> & quadrature,
- const std::map<types::boundary_id,
- const Function<spacedim, typename InputVector::value_type> *>
- & neumann_bc,
- const std::vector<const InputVector *> &solutions,
- std::vector<Vector<float> *> & errors,
- const ComponentMask & component_mask,
- const Function<spacedim> * coefficients,
- const unsigned int n_threads,
- const types::subdomain_id subdomain_id,
- const types::material_id material_id,
- const Strategy strategy)
+ const std::map<types::boundary_id, const Function<spacedim, Number> *>
+ & neumann_bc,
+ const std::vector<const ReadVector<Number> *> &solutions,
+ std::vector<Vector<float> *> & errors,
+ const ComponentMask & component_mask,
+ const Function<spacedim> * coefficients,
+ const unsigned int n_threads,
+ const types::subdomain_id subdomain_id,
+ const types::material_id material_id,
+ const Strategy strategy)
{
estimate(get_default_linear_mapping(dof_handler.get_triangulation()),
dof_handler,
template <int dim, int spacedim>
-template <typename InputVector>
+template <typename Number>
void
KellyErrorEstimator<dim, spacedim>::estimate(
const DoFHandler<dim, spacedim> &dof_handler,
const hp::QCollection<dim - 1> & quadrature,
- const std::map<types::boundary_id,
- const Function<spacedim, typename InputVector::value_type> *>
- & neumann_bc,
- const std::vector<const InputVector *> &solutions,
- std::vector<Vector<float> *> & errors,
- const ComponentMask & component_mask,
- const Function<spacedim> * coefficients,
- const unsigned int n_threads,
- const types::subdomain_id subdomain_id,
- const types::material_id material_id,
- const Strategy strategy)
+ const std::map<types::boundary_id, const Function<spacedim, Number> *>
+ & neumann_bc,
+ const std::vector<const ReadVector<Number> *> &solutions,
+ std::vector<Vector<float> *> & errors,
+ const ComponentMask & component_mask,
+ const Function<spacedim> * coefficients,
+ const unsigned int n_threads,
+ const types::subdomain_id subdomain_id,
+ const types::material_id material_id,
+ const Strategy strategy)
{
estimate(get_default_linear_mapping(dof_handler.get_triangulation()),
dof_handler,
#endif
}
-for (VEC : VECTOR_TYPES; deal_II_dimension : DIMENSIONS;
+for (S : REAL_AND_COMPLEX_SCALARS; deal_II_dimension : DIMENSIONS;
deal_II_space_dimension : SPACE_DIMENSIONS)
{
#if deal_II_dimension != 1 && deal_II_dimension <= deal_II_space_dimension
template void
KellyErrorEstimator<deal_II_dimension, deal_II_space_dimension>::estimate<
- VEC>(
- const Mapping<deal_II_dimension, deal_II_space_dimension> &,
- const DoFHandler<deal_II_dimension, deal_II_space_dimension> &,
- const Quadrature<deal_II_dimension - 1> &,
- const std::map<types::boundary_id,
- const Function<deal_II_space_dimension, VEC::value_type> *>
- &,
- const VEC &,
- Vector<float> &,
- const ComponentMask &,
- const Function<deal_II_space_dimension> *,
- const unsigned int,
- const types::subdomain_id,
- const types::material_id,
- const KellyErrorEstimator<deal_II_dimension,
- deal_II_space_dimension>::Strategy);
+ S>(const Mapping<deal_II_dimension, deal_II_space_dimension> &,
+ const DoFHandler<deal_II_dimension, deal_II_space_dimension> &,
+ const Quadrature<deal_II_dimension - 1> &,
+ const std::map<types::boundary_id,
+ const Function<deal_II_space_dimension, S> *> &,
+ const ReadVector<S> &,
+ Vector<float> &,
+ const ComponentMask &,
+ const Function<deal_II_space_dimension> *,
+ const unsigned int,
+ const types::subdomain_id,
+ const types::material_id,
+ const KellyErrorEstimator<deal_II_dimension,
+ deal_II_space_dimension>::Strategy);
template void
KellyErrorEstimator<deal_II_dimension, deal_II_space_dimension>::estimate<
- VEC>(
- const DoFHandler<deal_II_dimension, deal_II_space_dimension> &,
- const Quadrature<deal_II_dimension - 1> &,
- const std::map<types::boundary_id,
- const Function<deal_II_space_dimension, VEC::value_type> *>
- &,
- const VEC &,
- Vector<float> &,
- const ComponentMask &,
- const Function<deal_II_space_dimension> *,
- const unsigned int,
- const types::subdomain_id,
- const types::material_id,
- const KellyErrorEstimator<deal_II_dimension,
- deal_II_space_dimension>::Strategy);
+ S>(const DoFHandler<deal_II_dimension, deal_II_space_dimension> &,
+ const Quadrature<deal_II_dimension - 1> &,
+ const std::map<types::boundary_id,
+ const Function<deal_II_space_dimension, S> *> &,
+ const ReadVector<S> &,
+ Vector<float> &,
+ const ComponentMask &,
+ const Function<deal_II_space_dimension> *,
+ const unsigned int,
+ const types::subdomain_id,
+ const types::material_id,
+ const KellyErrorEstimator<deal_II_dimension,
+ deal_II_space_dimension>::Strategy);
template void
KellyErrorEstimator<deal_II_dimension, deal_II_space_dimension>::estimate<
- VEC>(
- const Mapping<deal_II_dimension, deal_II_space_dimension> &,
- const DoFHandler<deal_II_dimension, deal_II_space_dimension> &,
- const Quadrature<deal_II_dimension - 1> &,
- const std::map<types::boundary_id,
- const Function<deal_II_space_dimension, VEC::value_type> *>
- &,
- const std::vector<const VEC *> &,
- std::vector<Vector<float> *> &,
- const ComponentMask &,
- const Function<deal_II_space_dimension> *,
- const unsigned int,
- const types::subdomain_id,
- const types::material_id,
- const KellyErrorEstimator<deal_II_dimension,
- deal_II_space_dimension>::Strategy);
+ S>(const Mapping<deal_II_dimension, deal_II_space_dimension> &,
+ const DoFHandler<deal_II_dimension, deal_II_space_dimension> &,
+ const Quadrature<deal_II_dimension - 1> &,
+ const std::map<types::boundary_id,
+ const Function<deal_II_space_dimension, S> *> &,
+ const std::vector<const ReadVector<S> *> &,
+ std::vector<Vector<float> *> &,
+ const ComponentMask &,
+ const Function<deal_II_space_dimension> *,
+ const unsigned int,
+ const types::subdomain_id,
+ const types::material_id,
+ const KellyErrorEstimator<deal_II_dimension,
+ deal_II_space_dimension>::Strategy);
template void
KellyErrorEstimator<deal_II_dimension, deal_II_space_dimension>::estimate<
- VEC>(
- const DoFHandler<deal_II_dimension, deal_II_space_dimension> &,
- const Quadrature<deal_II_dimension - 1> &,
- const std::map<types::boundary_id,
- const Function<deal_II_space_dimension, VEC::value_type> *>
- &,
- const std::vector<const VEC *> &,
- std::vector<Vector<float> *> &,
- const ComponentMask &,
- const Function<deal_II_space_dimension> *,
- const unsigned int,
- const types::subdomain_id,
- const types::material_id,
- const KellyErrorEstimator<deal_II_dimension,
- deal_II_space_dimension>::Strategy);
+ S>(const DoFHandler<deal_II_dimension, deal_II_space_dimension> &,
+ const Quadrature<deal_II_dimension - 1> &,
+ const std::map<types::boundary_id,
+ const Function<deal_II_space_dimension, S> *> &,
+ const std::vector<const ReadVector<S> *> &,
+ std::vector<Vector<float> *> &,
+ const ComponentMask &,
+ const Function<deal_II_space_dimension> *,
+ const unsigned int,
+ const types::subdomain_id,
+ const types::material_id,
+ const KellyErrorEstimator<deal_II_dimension,
+ deal_II_space_dimension>::Strategy);
template void
KellyErrorEstimator<deal_II_dimension, deal_II_space_dimension>::estimate<
- VEC>(
- const Mapping<deal_II_dimension, deal_II_space_dimension> &,
- const DoFHandler<deal_II_dimension, deal_II_space_dimension> &,
- const hp::QCollection<deal_II_dimension - 1> &,
- const std::map<types::boundary_id,
- const Function<deal_II_space_dimension, VEC::value_type> *>
- &,
- const VEC &,
- Vector<float> &,
- const ComponentMask &,
- const Function<deal_II_space_dimension> *,
- const unsigned int,
- const types::subdomain_id,
- const types::material_id,
- const KellyErrorEstimator<deal_II_dimension,
- deal_II_space_dimension>::Strategy);
+ S>(const Mapping<deal_II_dimension, deal_II_space_dimension> &,
+ const DoFHandler<deal_II_dimension, deal_II_space_dimension> &,
+ const hp::QCollection<deal_II_dimension - 1> &,
+ const std::map<types::boundary_id,
+ const Function<deal_II_space_dimension, S> *> &,
+ const ReadVector<S> &,
+ Vector<float> &,
+ const ComponentMask &,
+ const Function<deal_II_space_dimension> *,
+ const unsigned int,
+ const types::subdomain_id,
+ const types::material_id,
+ const KellyErrorEstimator<deal_II_dimension,
+ deal_II_space_dimension>::Strategy);
template void
KellyErrorEstimator<deal_II_dimension, deal_II_space_dimension>::estimate<
- VEC>(
- const DoFHandler<deal_II_dimension, deal_II_space_dimension> &,
- const hp::QCollection<deal_II_dimension - 1> &,
- const std::map<types::boundary_id,
- const Function<deal_II_space_dimension, VEC::value_type> *>
- &,
- const VEC &,
- Vector<float> &,
- const ComponentMask &,
- const Function<deal_II_space_dimension> *,
- const unsigned int,
- const types::subdomain_id,
- const types::material_id,
- const KellyErrorEstimator<deal_II_dimension,
- deal_II_space_dimension>::Strategy);
+ S>(const DoFHandler<deal_II_dimension, deal_II_space_dimension> &,
+ const hp::QCollection<deal_II_dimension - 1> &,
+ const std::map<types::boundary_id,
+ const Function<deal_II_space_dimension, S> *> &,
+ const ReadVector<S> &,
+ Vector<float> &,
+ const ComponentMask &,
+ const Function<deal_II_space_dimension> *,
+ const unsigned int,
+ const types::subdomain_id,
+ const types::material_id,
+ const KellyErrorEstimator<deal_II_dimension,
+ deal_II_space_dimension>::Strategy);
template void
KellyErrorEstimator<deal_II_dimension, deal_II_space_dimension>::estimate<
- VEC>(
- const Mapping<deal_II_dimension, deal_II_space_dimension> &,
- const DoFHandler<deal_II_dimension, deal_II_space_dimension> &,
- const hp::QCollection<deal_II_dimension - 1> &,
- const std::map<types::boundary_id,
- const Function<deal_II_space_dimension, VEC::value_type> *>
- &,
- const std::vector<const VEC *> &,
- std::vector<Vector<float> *> &,
- const ComponentMask &,
- const Function<deal_II_space_dimension> *,
- const unsigned int,
- const types::subdomain_id,
- const types::material_id,
- const KellyErrorEstimator<deal_II_dimension,
- deal_II_space_dimension>::Strategy);
+ S>(const Mapping<deal_II_dimension, deal_II_space_dimension> &,
+ const DoFHandler<deal_II_dimension, deal_II_space_dimension> &,
+ const hp::QCollection<deal_II_dimension - 1> &,
+ const std::map<types::boundary_id,
+ const Function<deal_II_space_dimension, S> *> &,
+ const std::vector<const ReadVector<S> *> &,
+ std::vector<Vector<float> *> &,
+ const ComponentMask &,
+ const Function<deal_II_space_dimension> *,
+ const unsigned int,
+ const types::subdomain_id,
+ const types::material_id,
+ const KellyErrorEstimator<deal_II_dimension,
+ deal_II_space_dimension>::Strategy);
template void
KellyErrorEstimator<deal_II_dimension, deal_II_space_dimension>::estimate<
- VEC>(
- const DoFHandler<deal_II_dimension, deal_II_space_dimension> &,
- const hp::QCollection<deal_II_dimension - 1> &,
- const std::map<types::boundary_id,
- const Function<deal_II_space_dimension, VEC::value_type> *>
- &,
- const std::vector<const VEC *> &,
- std::vector<Vector<float> *> &,
- const ComponentMask &,
- const Function<deal_II_space_dimension> *,
- const unsigned int,
- const types::subdomain_id,
- const types::material_id,
- const KellyErrorEstimator<deal_II_dimension,
- deal_II_space_dimension>::Strategy);
+ S>(const DoFHandler<deal_II_dimension, deal_II_space_dimension> &,
+ const hp::QCollection<deal_II_dimension - 1> &,
+ const std::map<types::boundary_id,
+ const Function<deal_II_space_dimension, S> *> &,
+ const std::vector<const ReadVector<S> *> &,
+ std::vector<Vector<float> *> &,
+ const ComponentMask &,
+ const Function<deal_II_space_dimension> *,
+ const unsigned int,
+ const types::subdomain_id,
+ const types::material_id,
+ const KellyErrorEstimator<deal_II_dimension,
+ deal_II_space_dimension>::Strategy);
#endif
}
template <int spacedim>
-template <typename InputVector>
+template <typename Number>
void
KellyErrorEstimator<1, spacedim>::estimate(
const Mapping<1, spacedim> & mapping,
const DoFHandler<1, spacedim> &dof_handler,
const Quadrature<0> & quadrature,
- const std::map<types::boundary_id,
- const Function<spacedim, typename InputVector::value_type> *>
+ const std::map<types::boundary_id, const Function<spacedim, Number> *>
& neumann_bc,
- const InputVector & solution,
+ const ReadVector<Number> &solution,
Vector<float> & error,
const ComponentMask & component_mask,
const Function<spacedim> *coefficients,
const Strategy strategy)
{
// just pass on to the other function
- const std::vector<const InputVector *> solutions(1, &solution);
- std::vector<Vector<float> *> errors(1, &error);
+ const std::vector<const ReadVector<Number> *> solutions(1, &solution);
+ std::vector<Vector<float> *> errors(1, &error);
estimate(mapping,
dof_handler,
quadrature,
template <int spacedim>
-template <typename InputVector>
+template <typename Number>
void
KellyErrorEstimator<1, spacedim>::estimate(
const DoFHandler<1, spacedim> &dof_handler,
const Quadrature<0> & quadrature,
- const std::map<types::boundary_id,
- const Function<spacedim, typename InputVector::value_type> *>
+ const std::map<types::boundary_id, const Function<spacedim, Number> *>
& neumann_bc,
- const InputVector & solution,
+ const ReadVector<Number> &solution,
Vector<float> & error,
const ComponentMask & component_mask,
const Function<spacedim> *coefficients,
template <int spacedim>
-template <typename InputVector>
+template <typename Number>
void
KellyErrorEstimator<1, spacedim>::estimate(
const DoFHandler<1, spacedim> &dof_handler,
const Quadrature<0> & quadrature,
- const std::map<types::boundary_id,
- const Function<spacedim, typename InputVector::value_type> *>
- & neumann_bc,
- const std::vector<const InputVector *> &solutions,
- std::vector<Vector<float> *> & errors,
- const ComponentMask & component_mask,
- const Function<spacedim> * coefficients,
- const unsigned int n_threads,
- const types::subdomain_id subdomain_id,
- const types::material_id material_id,
- const Strategy strategy)
+ const std::map<types::boundary_id, const Function<spacedim, Number> *>
+ & neumann_bc,
+ const std::vector<const ReadVector<Number> *> &solutions,
+ std::vector<Vector<float> *> & errors,
+ const ComponentMask & component_mask,
+ const Function<spacedim> * coefficients,
+ const unsigned int n_threads,
+ const types::subdomain_id subdomain_id,
+ const types::material_id material_id,
+ const Strategy strategy)
{
const auto reference_cell = ReferenceCells::Line;
estimate(reference_cell.template get_default_linear_mapping<1, spacedim>(),
template <int spacedim>
-template <typename InputVector>
+template <typename Number>
void
KellyErrorEstimator<1, spacedim>::estimate(
const Mapping<1, spacedim> & mapping,
const DoFHandler<1, spacedim> &dof_handler,
const hp::QCollection<0> & quadrature,
- const std::map<types::boundary_id,
- const Function<spacedim, typename InputVector::value_type> *>
+ const std::map<types::boundary_id, const Function<spacedim, Number> *>
& neumann_bc,
- const InputVector & solution,
+ const ReadVector<Number> &solution,
Vector<float> & error,
const ComponentMask & component_mask,
const Function<spacedim> *coefficients,
const Strategy strategy)
{
// just pass on to the other function
- const std::vector<const InputVector *> solutions(1, &solution);
- std::vector<Vector<float> *> errors(1, &error);
+ const std::vector<const ReadVector<Number> *> solutions(1, &solution);
+ std::vector<Vector<float> *> errors(1, &error);
estimate(mapping,
dof_handler,
quadrature,
template <int spacedim>
-template <typename InputVector>
+template <typename Number>
void
KellyErrorEstimator<1, spacedim>::estimate(
const DoFHandler<1, spacedim> &dof_handler,
const hp::QCollection<0> & quadrature,
- const std::map<types::boundary_id,
- const Function<spacedim, typename InputVector::value_type> *>
+ const std::map<types::boundary_id, const Function<spacedim, Number> *>
& neumann_bc,
- const InputVector & solution,
+ const ReadVector<Number> &solution,
Vector<float> & error,
const ComponentMask & component_mask,
const Function<spacedim> *coefficients,
template <int spacedim>
-template <typename InputVector>
+template <typename Number>
void
KellyErrorEstimator<1, spacedim>::estimate(
const DoFHandler<1, spacedim> &dof_handler,
const hp::QCollection<0> & quadrature,
- const std::map<types::boundary_id,
- const Function<spacedim, typename InputVector::value_type> *>
- & neumann_bc,
- const std::vector<const InputVector *> &solutions,
- std::vector<Vector<float> *> & errors,
- const ComponentMask & component_mask,
- const Function<spacedim> * coefficients,
- const unsigned int n_threads,
- const types::subdomain_id subdomain_id,
- const types::material_id material_id,
- const Strategy strategy)
+ const std::map<types::boundary_id, const Function<spacedim, Number> *>
+ & neumann_bc,
+ const std::vector<const ReadVector<Number> *> &solutions,
+ std::vector<Vector<float> *> & errors,
+ const ComponentMask & component_mask,
+ const Function<spacedim> * coefficients,
+ const unsigned int n_threads,
+ const types::subdomain_id subdomain_id,
+ const types::material_id material_id,
+ const Strategy strategy)
{
const auto reference_cell = ReferenceCells::Line;
estimate(reference_cell.template get_default_linear_mapping<1, spacedim>(),
template <int spacedim>
-template <typename InputVector>
+template <typename Number>
void
KellyErrorEstimator<1, spacedim>::estimate(
const Mapping<1, spacedim> & mapping,
const DoFHandler<1, spacedim> &dof_handler,
const hp::QCollection<0> &,
- const std::map<types::boundary_id,
- const Function<spacedim, typename InputVector::value_type> *>
- & neumann_bc,
- const std::vector<const InputVector *> &solutions,
- std::vector<Vector<float> *> & errors,
- const ComponentMask & component_mask,
- const Function<spacedim> * coefficient,
+ const std::map<types::boundary_id, const Function<spacedim, Number> *>
+ & neumann_bc,
+ const std::vector<const ReadVector<Number> *> &solutions,
+ std::vector<Vector<float> *> & errors,
+ const ComponentMask & component_mask,
+ const Function<spacedim> * coefficient,
const unsigned int,
const types::subdomain_id subdomain_id_,
const types::material_id material_id,
const Strategy strategy)
{
AssertThrow(strategy == cell_diameter_over_24, ExcNotImplemented());
- using number = typename InputVector::value_type;
+ using number = Number;
types::subdomain_id subdomain_id = numbers::invalid_subdomain_id;
if (const auto *triangulation = dynamic_cast<
const parallel::DistributedTriangulationBase<1, spacedim> *>(
{
if (n_components == 1)
{
- const typename InputVector::value_type v =
+ const Number v =
neumann_bc.find(n)->second->value(cell->vertex(n));
for (unsigned int s = 0; s < n_solution_vectors; ++s)
}
else
{
- Vector<typename InputVector::value_type> v(n_components);
+ Vector<Number> v(n_components);
neumann_bc.find(n)->second->vector_value(cell->vertex(n),
v);
template <int spacedim>
-template <typename InputVector>
+template <typename Number>
void
KellyErrorEstimator<1, spacedim>::estimate(
const Mapping<1, spacedim> & mapping,
const DoFHandler<1, spacedim> &dof_handler,
const Quadrature<0> & quadrature,
- const std::map<types::boundary_id,
- const Function<spacedim, typename InputVector::value_type> *>
- & neumann_bc,
- const std::vector<const InputVector *> &solutions,
- std::vector<Vector<float> *> & errors,
- const ComponentMask & component_mask,
- const Function<spacedim> * coefficients,
- const unsigned int n_threads,
- const types::subdomain_id subdomain_id,
- const types::material_id material_id,
- const Strategy strategy)
+ const std::map<types::boundary_id, const Function<spacedim, Number> *>
+ & neumann_bc,
+ const std::vector<const ReadVector<Number> *> &solutions,
+ std::vector<Vector<float> *> & errors,
+ const ComponentMask & component_mask,
+ const Function<spacedim> * coefficients,
+ const unsigned int n_threads,
+ const types::subdomain_id subdomain_id,
+ const types::material_id material_id,
+ const Strategy strategy)
{
const hp::QCollection<0> quadrature_collection(quadrature);
estimate(mapping,
// ---------------------------------------------------------------------
-for (VEC : VECTOR_TYPES; deal_II_dimension : DIMENSIONS;
+for (S : REAL_AND_COMPLEX_SCALARS; deal_II_dimension : DIMENSIONS;
deal_II_space_dimension : SPACE_DIMENSIONS)
{
#if deal_II_dimension == 1 && deal_II_dimension <= deal_II_space_dimension
template void
KellyErrorEstimator<deal_II_dimension, deal_II_space_dimension>::estimate<
- VEC>(
- const Mapping<deal_II_dimension, deal_II_space_dimension> &,
- const DoFHandler<deal_II_dimension, deal_II_space_dimension> &,
- const Quadrature<deal_II_dimension - 1> &,
- const std::map<types::boundary_id,
- const Function<deal_II_space_dimension, VEC::value_type> *>
- &,
- const VEC &,
- Vector<float> &,
- const ComponentMask &,
- const Function<deal_II_space_dimension> *,
- const unsigned int,
- const types::subdomain_id,
- const types::material_id,
- const Strategy);
+ S>(const Mapping<deal_II_dimension, deal_II_space_dimension> &,
+ const DoFHandler<deal_II_dimension, deal_II_space_dimension> &,
+ const Quadrature<deal_II_dimension - 1> &,
+ const std::map<types::boundary_id,
+ const Function<deal_II_space_dimension, S> *> &,
+ const ReadVector<S> &,
+ Vector<float> &,
+ const ComponentMask &,
+ const Function<deal_II_space_dimension> *,
+ const unsigned int,
+ const types::subdomain_id,
+ const types::material_id,
+ const Strategy);
template void
KellyErrorEstimator<deal_II_dimension, deal_II_space_dimension>::estimate<
- VEC>(
- const DoFHandler<deal_II_dimension, deal_II_space_dimension> &,
- const Quadrature<deal_II_dimension - 1> &,
- const std::map<types::boundary_id,
- const Function<deal_II_space_dimension, VEC::value_type> *>
- &,
- const VEC &,
- Vector<float> &,
- const ComponentMask &,
- const Function<deal_II_space_dimension> *,
- const unsigned int,
- const types::subdomain_id,
- const types::material_id,
- const Strategy);
+ S>(const DoFHandler<deal_II_dimension, deal_II_space_dimension> &,
+ const Quadrature<deal_II_dimension - 1> &,
+ const std::map<types::boundary_id,
+ const Function<deal_II_space_dimension, S> *> &,
+ const ReadVector<S> &,
+ Vector<float> &,
+ const ComponentMask &,
+ const Function<deal_II_space_dimension> *,
+ const unsigned int,
+ const types::subdomain_id,
+ const types::material_id,
+ const Strategy);
template void
KellyErrorEstimator<deal_II_dimension, deal_II_space_dimension>::estimate<
- VEC>(
- const Mapping<deal_II_dimension, deal_II_space_dimension> &,
- const DoFHandler<deal_II_dimension, deal_II_space_dimension> &,
- const Quadrature<deal_II_dimension - 1> &,
- const std::map<types::boundary_id,
- const Function<deal_II_space_dimension, VEC::value_type> *>
- &,
- const std::vector<const VEC *> &,
- std::vector<Vector<float> *> &,
- const ComponentMask &,
- const Function<deal_II_space_dimension> *,
- const unsigned int,
- const types::subdomain_id,
- const types::material_id,
- const Strategy);
+ S>(const Mapping<deal_II_dimension, deal_II_space_dimension> &,
+ const DoFHandler<deal_II_dimension, deal_II_space_dimension> &,
+ const Quadrature<deal_II_dimension - 1> &,
+ const std::map<types::boundary_id,
+ const Function<deal_II_space_dimension, S> *> &,
+ const std::vector<const ReadVector<S> *> &,
+ std::vector<Vector<float> *> &,
+ const ComponentMask &,
+ const Function<deal_II_space_dimension> *,
+ const unsigned int,
+ const types::subdomain_id,
+ const types::material_id,
+ const Strategy);
template void
KellyErrorEstimator<deal_II_dimension, deal_II_space_dimension>::estimate<
- VEC>(
- const DoFHandler<deal_II_dimension, deal_II_space_dimension> &,
- const Quadrature<deal_II_dimension - 1> &,
- const std::map<types::boundary_id,
- const Function<deal_II_space_dimension, VEC::value_type> *>
- &,
- const std::vector<const VEC *> &,
- std::vector<Vector<float> *> &,
- const ComponentMask &,
- const Function<deal_II_space_dimension> *,
- const unsigned int,
- const types::subdomain_id,
- const types::material_id,
- const Strategy);
+ S>(const DoFHandler<deal_II_dimension, deal_II_space_dimension> &,
+ const Quadrature<deal_II_dimension - 1> &,
+ const std::map<types::boundary_id,
+ const Function<deal_II_space_dimension, S> *> &,
+ const std::vector<const ReadVector<S> *> &,
+ std::vector<Vector<float> *> &,
+ const ComponentMask &,
+ const Function<deal_II_space_dimension> *,
+ const unsigned int,
+ const types::subdomain_id,
+ const types::material_id,
+ const Strategy);
template void
KellyErrorEstimator<deal_II_dimension, deal_II_space_dimension>::estimate<
- VEC>(
- const Mapping<deal_II_dimension, deal_II_space_dimension> &,
- const DoFHandler<deal_II_dimension, deal_II_space_dimension> &,
- const hp::QCollection<deal_II_dimension - 1> &,
- const std::map<types::boundary_id,
- const Function<deal_II_space_dimension, VEC::value_type> *>
- &,
- const VEC &,
- Vector<float> &,
- const ComponentMask &,
- const Function<deal_II_space_dimension> *,
- const unsigned int,
- const types::subdomain_id,
- const types::material_id,
- const Strategy);
+ S>(const Mapping<deal_II_dimension, deal_II_space_dimension> &,
+ const DoFHandler<deal_II_dimension, deal_II_space_dimension> &,
+ const hp::QCollection<deal_II_dimension - 1> &,
+ const std::map<types::boundary_id,
+ const Function<deal_II_space_dimension, S> *> &,
+ const ReadVector<S> &,
+ Vector<float> &,
+ const ComponentMask &,
+ const Function<deal_II_space_dimension> *,
+ const unsigned int,
+ const types::subdomain_id,
+ const types::material_id,
+ const Strategy);
template void
KellyErrorEstimator<deal_II_dimension, deal_II_space_dimension>::estimate<
- VEC>(
- const DoFHandler<deal_II_dimension, deal_II_space_dimension> &,
- const hp::QCollection<deal_II_dimension - 1> &,
- const std::map<types::boundary_id,
- const Function<deal_II_space_dimension, VEC::value_type> *>
- &,
- const VEC &,
- Vector<float> &,
- const ComponentMask &,
- const Function<deal_II_space_dimension> *,
- const unsigned int,
- const types::subdomain_id,
- const types::material_id,
- const Strategy);
+ S>(const DoFHandler<deal_II_dimension, deal_II_space_dimension> &,
+ const hp::QCollection<deal_II_dimension - 1> &,
+ const std::map<types::boundary_id,
+ const Function<deal_II_space_dimension, S> *> &,
+ const ReadVector<S> &,
+ Vector<float> &,
+ const ComponentMask &,
+ const Function<deal_II_space_dimension> *,
+ const unsigned int,
+ const types::subdomain_id,
+ const types::material_id,
+ const Strategy);
template void
KellyErrorEstimator<deal_II_dimension, deal_II_space_dimension>::estimate<
- VEC>(
- const Mapping<deal_II_dimension, deal_II_space_dimension> &,
- const DoFHandler<deal_II_dimension, deal_II_space_dimension> &,
- const hp::QCollection<deal_II_dimension - 1> &,
- const std::map<types::boundary_id,
- const Function<deal_II_space_dimension, VEC::value_type> *>
- &,
- const std::vector<const VEC *> &,
- std::vector<Vector<float> *> &,
- const ComponentMask &,
- const Function<deal_II_space_dimension> *,
- const unsigned int,
- const types::subdomain_id,
- const types::material_id,
- const Strategy);
+ S>(const Mapping<deal_II_dimension, deal_II_space_dimension> &,
+ const DoFHandler<deal_II_dimension, deal_II_space_dimension> &,
+ const hp::QCollection<deal_II_dimension - 1> &,
+ const std::map<types::boundary_id,
+ const Function<deal_II_space_dimension, S> *> &,
+ const std::vector<const ReadVector<S> *> &,
+ std::vector<Vector<float> *> &,
+ const ComponentMask &,
+ const Function<deal_II_space_dimension> *,
+ const unsigned int,
+ const types::subdomain_id,
+ const types::material_id,
+ const Strategy);
template void
KellyErrorEstimator<deal_II_dimension, deal_II_space_dimension>::estimate<
- VEC>(
- const DoFHandler<deal_II_dimension, deal_II_space_dimension> &,
- const hp::QCollection<deal_II_dimension - 1> &,
- const std::map<types::boundary_id,
- const Function<deal_II_space_dimension, VEC::value_type> *>
- &,
- const std::vector<const VEC *> &,
- std::vector<Vector<float> *> &,
- const ComponentMask &,
- const Function<deal_II_space_dimension> *,
- const unsigned int,
- const types::subdomain_id,
- const types::material_id,
- const Strategy);
+ S>(const DoFHandler<deal_II_dimension, deal_II_space_dimension> &,
+ const hp::QCollection<deal_II_dimension - 1> &,
+ const std::map<types::boundary_id,
+ const Function<deal_II_space_dimension, S> *> &,
+ const std::vector<const ReadVector<S> *> &,
+ std::vector<Vector<float> *> &,
+ const ComponentMask &,
+ const Function<deal_II_space_dimension> *,
+ const unsigned int,
+ const types::subdomain_id,
+ const types::material_id,
+ const Strategy);
#endif
}