Rename FEEvaluationBaseData to FEEvaluationData.
#include <deal.II/matrix_free/evaluation_flags.h>
#include <deal.II/matrix_free/evaluation_template_factory.h>
-#include <deal.II/matrix_free/fe_evaluation_base_data.h>
+#include <deal.II/matrix_free/fe_evaluation_data.h>
#include <deal.II/matrix_free/mapping_info_storage.h>
#include <deal.II/matrix_free/shape_info.h>
#include <deal.II/matrix_free/tensor_product_kernels.h>
}
internal::MatrixFreeFunctions::
- MappingInfoStorage<dim, dim, double, VectorizedArrayType>
+ MappingInfoStorage<dim, dim, VectorizedArrayType>
temp_data;
temp_data.descriptor.resize(1);
temp_data.descriptor[0].n_q_points = n_q_points;
- FEEvaluationBaseData<dim, double, false, VectorizedArrayType> eval(
+ FEEvaluationData<dim, VectorizedArrayType, false> eval(
{&data.shape_info, nullptr, &temp_data, 0, 0});
// prepare arrays
}
// do the actual tensorized evaluation
- internal::FEEvaluationFactory<dim, double, VectorizedArrayType>::
- evaluate(n_comp, evaluation_flag, eval.begin_dof_values(), eval);
+ internal::FEEvaluationFactory<dim, VectorizedArrayType>::evaluate(
+ n_comp, evaluation_flag, eval.begin_dof_values(), eval);
}
// do the postprocessing
#include <deal.II/matrix_free/dof_info.h>
#include <deal.II/matrix_free/evaluation_flags.h>
-#include <deal.II/matrix_free/fe_evaluation_base_data.h>
+#include <deal.II/matrix_free/fe_evaluation_data.h>
#include <deal.II/matrix_free/hanging_nodes_internal.h>
#include <deal.II/matrix_free/shape_info.h>
#include <deal.II/matrix_free/tensor_product_kernels.h>
-#include <deal.II/matrix_free/type_traits.h>
DEAL_II_NAMESPACE_OPEN
n_q_points_1d,
Number>;
- using EvaluationData =
- FEEvaluationBaseData<dim, typename Number::value_type, false, Number>;
-
static void
evaluate(const unsigned int n_components,
const EvaluationFlags::EvaluationFlags evaluation_flag,
const Number * values_dofs_actual,
- EvaluationData & eval);
+ FEEvaluationData<dim, Number, false> & eval);
static void
integrate(const unsigned int n_components,
const EvaluationFlags::EvaluationFlags integration_flag,
Number * values_dofs_actual,
- EvaluationData & eval,
+ FEEvaluationData<dim, Number, false> & eval,
const bool add_into_values_array);
static Eval
n_q_points_1d,
Number>
{
- using EvaluationData =
- FEEvaluationBaseData<dim, typename Number::value_type, false, Number>;
-
static void
evaluate(const unsigned int n_components,
const EvaluationFlags::EvaluationFlags evaluation_flag,
const Number * values_dofs_actual,
- EvaluationData & eval);
+ FEEvaluationData<dim, Number, false> & eval);
static void
integrate(const unsigned int n_components,
const EvaluationFlags::EvaluationFlags integration_flag,
Number * values_dofs_actual,
- EvaluationData & eval,
+ FEEvaluationData<dim, Number, false> & eval,
const bool add_into_values_array);
};
const unsigned int n_components,
const EvaluationFlags::EvaluationFlags evaluation_flag,
const Number * values_dofs_actual,
- EvaluationData & eval)
+ FEEvaluationData<dim, Number, false> & eval)
{
if (evaluation_flag == EvaluationFlags::nothing)
return;
const Number *values_dofs = values_dofs_actual;
if (type == MatrixFreeFunctions::truncated_tensor)
{
- const std::size_t stored_dofs_per_comp =
+ const std::size_t n_dofs_per_comp =
eval.get_shape_info().dofs_per_component_on_cell;
Number *values_dofs_tmp =
- temp1 + 2 * (std::max(stored_dofs_per_comp, n_q_points));
+ temp1 + 2 * (std::max(n_dofs_per_comp, n_q_points));
const int degree =
fe_degree != -1 ? fe_degree : shape_data[0].fe_degree;
for (unsigned int c = 0; c < n_components; ++c)
for (int k = 0; k < degree + 1 - j - i;
++k, ++count_p, ++count_q)
values_dofs_tmp[c * dofs_per_comp + count_q] =
- values_dofs_actual[c * stored_dofs_per_comp + count_p];
+ values_dofs_actual[c * n_dofs_per_comp + count_p];
for (int k = degree + 1 - j - i; k < degree + 1;
++k, ++count_q)
values_dofs_tmp[c * dofs_per_comp + count_q] = Number();
const unsigned int n_components,
const EvaluationFlags::EvaluationFlags integration_flag,
Number * values_dofs_actual,
- EvaluationData & eval,
+ FEEvaluationData<dim, Number, false> & eval,
const bool add_into_values_array)
{
std::array<const MatrixFreeFunctions::UnivariateShapeData<Number> *, 3>
temp2 = temp1 + temp_size;
}
- const unsigned int n_q_points = temp_size == 0 ?
+ const std::size_t n_q_points = temp_size == 0 ?
eval.get_shape_info().n_q_points :
Eval::n_columns_of_product;
const unsigned int dofs_per_comp =
// expand dof_values to tensor product for truncated tensor products
Number *values_dofs =
(type == MatrixFreeFunctions::truncated_tensor) ?
- temp1 + 2 * (std::max(eval.get_shape_info().dofs_per_component_on_cell,
- n_q_points)) :
+ temp1 +
+ 2 * (std::max<std::size_t>(
+ eval.get_shape_info().dofs_per_component_on_cell, n_q_points)) :
values_dofs_actual;
Number *values_quad = eval.begin_values();
if (type == MatrixFreeFunctions::truncated_tensor)
{
- const std::size_t stored_dofs_per_comp =
+ const std::size_t n_dofs_per_comp =
eval.get_shape_info().dofs_per_component_on_cell;
values_dofs -= dofs_per_comp * n_components;
const int degree =
{
for (int k = 0; k < degree + 1 - j - i;
++k, ++count_p, ++count_q)
- values_dofs_actual[c * stored_dofs_per_comp + count_p] =
+ values_dofs_actual[c * n_dofs_per_comp + count_p] =
values_dofs[c * dofs_per_comp + count_q];
count_q += j + i;
}
n_q_points_1d,
Number>::evaluate(const unsigned int n_components,
const EvaluationFlags::EvaluationFlags
- evaluation_flag,
- const Number * values_dofs_actual,
- EvaluationData &eval)
+ evaluation_flag,
+ const Number *values_dofs_actual,
+ FEEvaluationData<dim, Number, false> &eval)
{
- const unsigned int n_dofs =
- eval.get_shape_info().dofs_per_component_on_cell;
- const unsigned int n_q_points = eval.get_shape_info().n_q_points;
+ const std::size_t n_dofs = eval.get_shape_info().dofs_per_component_on_cell;
+ const std::size_t n_q_points = eval.get_shape_info().n_q_points;
const auto &shape_data = eval.get_shape_info().data;
template <int dim, int fe_degree, int n_q_points_1d, typename Number>
inline void
- FEEvaluationImpl<MatrixFreeFunctions::tensor_none,
- dim,
- fe_degree,
- n_q_points_1d,
- Number>::integrate(const unsigned int n_components,
- const EvaluationFlags::EvaluationFlags
- integration_flag,
- Number * values_dofs_actual,
- EvaluationData &eval,
- const bool add_into_values_array)
+ FEEvaluationImpl<
+ MatrixFreeFunctions::tensor_none,
+ dim,
+ fe_degree,
+ n_q_points_1d,
+ Number>::integrate(const unsigned int n_components,
+ const EvaluationFlags::EvaluationFlags integration_flag,
+ Number * values_dofs_actual,
+ FEEvaluationData<dim, Number, false> &eval,
+ const bool add_into_values_array)
{
// TODO: implement hessians
AssertThrow(!(integration_flag & EvaluationFlags::hessians),
ExcNotImplemented());
- const unsigned int n_dofs =
- eval.get_shape_info().dofs_per_component_on_cell;
- const unsigned int n_q_points = eval.get_shape_info().n_q_points;
+ const std::size_t n_dofs = eval.get_shape_info().dofs_per_component_on_cell;
+ const std::size_t n_q_points = eval.get_shape_info().n_q_points;
const auto &shape_data = eval.get_shape_info().data;
template <int dim, int fe_degree, typename Number>
struct FEEvaluationImplCollocation
{
- using EvaluationData =
- FEEvaluationBaseData<dim, typename Number::value_type, false, Number>;
-
static void
evaluate(const unsigned int n_components,
const EvaluationFlags::EvaluationFlags evaluation_flag,
const Number * values_dofs,
- EvaluationData & eval);
+ FEEvaluationData<dim, Number, false> & eval);
static void
do_evaluate(const MatrixFreeFunctions::UnivariateShapeData<Number> &shape,
integrate(const unsigned int n_components,
const EvaluationFlags::EvaluationFlags integration_flag,
Number * values_dofs,
- EvaluationData & eval,
+ FEEvaluationData<dim, Number, false> & eval,
const bool add_into_values_array);
static void
const unsigned int n_components,
const EvaluationFlags::EvaluationFlags evaluation_flag,
const Number * values_dofs,
- EvaluationData & eval)
+ FEEvaluationData<dim, Number, false> & eval)
{
constexpr std::size_t n_points = Utilities::pow(fe_degree + 1, dim);
const unsigned int n_components,
const EvaluationFlags::EvaluationFlags integration_flag,
Number * values_dofs,
- EvaluationData & eval,
+ FEEvaluationData<dim, Number, false> & eval,
const bool add_into_values_array)
{
constexpr std::size_t n_points = Utilities::pow(fe_degree + 1, dim);
template <int dim, int fe_degree, int n_q_points_1d, typename Number>
struct FEEvaluationImplTransformToCollocation
{
- using EvaluationData =
- FEEvaluationBaseData<dim, typename Number::value_type, false, Number>;
-
static void
evaluate(const unsigned int n_components,
const EvaluationFlags::EvaluationFlags evaluation_flag,
const Number * values_dofs,
- EvaluationData & eval);
+ FEEvaluationData<dim, Number, false> & eval);
static void
integrate(const unsigned int n_components,
const EvaluationFlags::EvaluationFlags evaluation_flag,
Number * values_dofs,
- EvaluationData & eval,
+ FEEvaluationData<dim, Number, false> & eval,
const bool add_into_values_array);
};
Number>::evaluate(const unsigned int n_components,
const EvaluationFlags::EvaluationFlags evaluation_flag,
const Number * values_dofs,
- EvaluationData & eval)
+ FEEvaluationData<dim, Number, false> & eval)
{
const auto &shape_data = eval.get_shape_info().data[0];
"of lower degree, so the evaluation results would be "
"wrong. Thus, this class does not permit the desired "
"operation."));
+ constexpr std::size_t n_dofs = Utilities::pow(fe_degree + 1, dim);
constexpr std::size_t n_q_points = Utilities::pow(n_q_points_1d, dim);
for (unsigned int c = 0; c < n_components; ++c)
Number,
Number>::do_forward(1,
shape_data.shape_values_eo,
- values_dofs +
- c * Utilities::pow(fe_degree + 1, dim),
+ values_dofs + c * n_dofs,
eval.begin_values() + c * n_q_points);
// apply derivatives in the collocation space
Number>::integrate(const unsigned int n_components,
const EvaluationFlags::EvaluationFlags integration_flag,
Number * values_dofs,
- EvaluationData & eval,
+ FEEvaluationData<dim, Number, false> & eval,
const bool add_into_values_array)
{
const auto &shape_data = eval.get_shape_info().data[0];
"of lower degree, so the evaluation results would be "
"wrong. Thus, this class does not permit the desired "
"operation."));
- constexpr unsigned int n_q_points = Utilities::pow(n_q_points_1d, dim);
+ constexpr std::size_t n_q_points = Utilities::pow(n_q_points_1d, dim);
for (unsigned int c = 0; c < n_components; ++c)
{
+ /**
+ * Helper function to specify whether transformation to collocation should
+ * be used: It should give correct results (first condition), we need to be
+ * able to initialize the fields in shape_info.templates.h from the
+ * polynomials (second condition), and it should be the most efficient
+ * choice in terms of operation counts (third condition).
+ */
+ constexpr bool
+ use_collocation_evaluation(const unsigned int fe_degree,
+ const unsigned int n_q_points_1d)
+ {
+ return (n_q_points_1d > fe_degree) && (n_q_points_1d < 200) &&
+ (n_q_points_1d <= 3 * fe_degree / 2 + 1);
+ }
+
+
/**
* This class chooses an appropriate evaluation strategy based on the
* template parameters and the shape_info variable which contains runtime
run(const unsigned int n_components,
const EvaluationFlags::EvaluationFlags evaluation_flag,
const Number * values_dofs,
- FEEvaluationBaseData<dim, typename Number::value_type, false, Number>
- &eval)
+ FEEvaluationData<dim, Number, false> & eval)
{
const auto element_type = eval.get_shape_info().element_type;
using ElementType = internal::MatrixFreeFunctions::ElementType;
- // We enable a transformation to collocation for derivatives if it gives
- // correct results (first condition), if it is the most efficient choice
- // in terms of operation counts (second condition) and if we were able to
- // initialize the fields in shape_info.templates.h from the polynomials
- // (third condition).
- constexpr bool use_collocation = (n_q_points_1d > fe_degree) &&
- (n_q_points_1d < 200) &&
- (n_q_points_1d <= 3 * fe_degree / 2 + 1);
-
Assert(eval.get_shape_info().data.size() == 1 ||
(eval.get_shape_info().data.size() == dim &&
element_type == ElementType::tensor_general),
}
// '<=' on type means tensor_symmetric or tensor_symmetric_hermite, see
// shape_info.h for more details
- else if (fe_degree >= 0 && use_collocation &&
+ else if (fe_degree >= 0 &&
+ use_collocation_evaluation(fe_degree, n_q_points_1d) &&
element_type <= ElementType::tensor_symmetric)
{
internal::FEEvaluationImplTransformToCollocation<
run(const unsigned int n_components,
const EvaluationFlags::EvaluationFlags integration_flag,
Number * values_dofs,
- FEEvaluationBaseData<dim, typename Number::value_type, false, Number>
- & eval,
- const bool sum_into_values_array)
+ FEEvaluationData<dim, Number, false> & eval,
+ const bool sum_into_values_array)
{
const auto element_type = eval.get_shape_info().element_type;
using ElementType = internal::MatrixFreeFunctions::ElementType;
- // We enable a transformation to collocation for derivatives if it gives
- // correct results (first condition), if it is the most efficient choice
- // in terms of operation counts (second condition) and if we were able to
- // initialize the fields in shape_info.templates.h from the polynomials
- // (third condition).
- constexpr bool use_collocation = (n_q_points_1d > fe_degree) &&
- (n_q_points_1d < 200) &&
- (n_q_points_1d <= 3 * fe_degree / 2 + 1);
-
Assert(eval.get_shape_info().data.size() == 1 ||
(eval.get_shape_info().data.size() == dim &&
element_type == ElementType::tensor_general),
}
// '<=' on type means tensor_symmetric or tensor_symmetric_hermite, see
// shape_info.h for more details
- else if (fe_degree >= 0 && use_collocation &&
+ else if (fe_degree >= 0 &&
+ use_collocation_evaluation(fe_degree, n_q_points_1d) &&
element_type <= ElementType::tensor_symmetric)
{
internal::FEEvaluationImplTransformToCollocation<
// choice in terms of operation counts (third condition) and if we were
// able to initialize the fields in shape_info.templates.h from the
// polynomials (fourth condition).
- static constexpr bool use_collocation =
- symmetric_evaluate && (n_q_points_1d > fe_degree) &&
- (n_q_points_1d < 200) && (n_q_points_1d <= 3 * fe_degree / 2 + 1);
-
using Eval =
EvaluatorTensorProduct<symmetric_evaluate ? internal::evaluate_evenodd :
internal::evaluate_general,
n_q_points_1d,
Number>;
- using EvaluationData =
- FEEvaluationBaseData<dim, typename Number::value_type, true, Number>;
-
static Eval
create_evaluator_tensor_product(
const internal::MatrixFreeFunctions::UnivariateShapeData<Number> &data,
Eval eval0 = create_evaluator_tensor_product(data, subface_index, 0);
Eval eval1 = create_evaluator_tensor_product(data, subface_index, 1);
- const std::size_t size_deg =
- fe_degree > -1 ? Utilities::pow(fe_degree + 1, dim - 1) :
- Utilities::pow(data.fe_degree + 1, dim - 1);
+ const std::size_t n_dofs = fe_degree > -1 ?
+ Utilities::pow(fe_degree + 1, dim - 1) :
+ Utilities::pow(data.fe_degree + 1, dim - 1);
const std::size_t n_q_points =
fe_degree > -1 ? Utilities::pow(n_q_points_1d, dim - 1) :
Utilities::pow(data.n_q_points_1d, dim - 1);
default:
Assert(false, ExcNotImplemented());
}
- values_dofs += 3 * size_deg;
+ // Note: we always keep storage of values, 1st and 2nd derivatives
+ // in an array
+ values_dofs += 3 * n_dofs;
values_quad += n_q_points;
}
else if (evaluation_flag & EvaluationFlags::gradients)
switch (dim)
{
case 3:
- if (use_collocation)
+ if (symmetric_evaluate &&
+ use_collocation_evaluation(fe_degree, n_q_points_1d))
{
eval0.template values<0, true, false>(values_dofs,
values_quad);
values_quad);
}
// grad z
- eval0.template values<0, true, false>(values_dofs + size_deg,
+ eval0.template values<0, true, false>(values_dofs + n_dofs,
scratch_data);
eval1.template values<1, true, false>(
scratch_data, gradients_quad + (dim - 1) * n_q_points);
break;
case 2:
- eval0.template values<0, true, false>(values_dofs + size_deg,
+ eval0.template values<0, true, false>(values_dofs + n_dofs,
gradients_quad +
n_q_points);
eval0.template gradients<0, true, false>(values_dofs,
default:
AssertThrow(false, ExcNotImplemented());
}
- values_dofs += 3 * size_deg;
+ values_dofs += 3 * n_dofs;
values_quad += n_q_points;
gradients_quad += dim * n_q_points;
}
// grad zz
eval0.template values<0, true, false>(values_dofs +
- 2 * size_deg,
+ 2 * n_dofs,
scratch_data);
eval1.template values<1, true, false>(scratch_data,
hessians_quad +
// grad xz
eval0.template gradients<0, true, false>(values_dofs +
- size_deg,
+ n_dofs,
scratch_data);
eval1.template values<1, true, false>(scratch_data,
hessians_quad +
4 * n_q_points);
// grad yz
- eval0.template values<0, true, false>(values_dofs +
- size_deg,
+ eval0.template values<0, true, false>(values_dofs + n_dofs,
scratch_data);
eval1.template gradients<1, true, false>(scratch_data,
hessians_quad +
hessians_quad);
// grad yy
eval0.template values<0, true, false>(
- values_dofs + 2 * size_deg, hessians_quad + n_q_points);
+ values_dofs + 2 * n_dofs, hessians_quad + n_q_points);
// grad xy
eval0.template gradients<0, true, false>(
- values_dofs + size_deg, hessians_quad + 2 * n_q_points);
+ values_dofs + n_dofs, hessians_quad + 2 * n_q_points);
break;
case 1:
hessians_quad[0] = values_dofs[2];
default:
AssertThrow(false, ExcNotImplemented());
}
- values_dofs += 3 * size_deg;
+ values_dofs += 3 * n_dofs;
hessians_quad += dim * (dim + 1) / 2 * n_q_points;
}
}
Eval eval0 = create_evaluator_tensor_product(data, subface_index, 0);
Eval eval1 = create_evaluator_tensor_product(data, subface_index, 1);
- const std::size_t size_deg =
+ const std::size_t n_dofs =
fe_degree > -1 ?
Utilities::pow(fe_degree + 1, dim - 1) :
(dim > 1 ? Utilities::fixed_power<dim - 1>(data.fe_degree + 1) : 1);
default:
Assert(false, ExcNotImplemented());
}
- values_dofs += 3 * size_deg;
+ values_dofs += 3 * n_dofs;
values_quad += n_q_points;
}
else if (integration_flag & EvaluationFlags::gradients)
2 * n_q_points,
gradients_quad +
2 * n_q_points);
- eval0.template values<0, false, false>(
- gradients_quad + 2 * n_q_points, values_dofs + size_deg);
- if (use_collocation)
+ eval0.template values<0, false, false>(gradients_quad +
+ 2 * n_q_points,
+ values_dofs + n_dofs);
+ if (symmetric_evaluate &&
+ use_collocation_evaluation(fe_degree, n_q_points_1d))
{
internal::EvaluatorTensorProduct<
internal::evaluate_evenodd,
}
break;
case 2:
- eval0.template values<0, false, false>(
- gradients_quad + n_q_points, values_dofs + size_deg);
+ eval0.template values<0, false, false>(gradients_quad +
+ n_q_points,
+ values_dofs + n_dofs);
eval0.template gradients<0, false, false>(gradients_quad,
values_dofs);
if (integration_flag & EvaluationFlags::values)
default:
AssertThrow(false, ExcNotImplemented());
}
- values_dofs += 3 * size_deg;
+ values_dofs += 3 * n_dofs;
values_quad += n_q_points;
gradients_quad += dim * n_q_points;
}
scratch_data);
eval0.template values<0, false, false>(scratch_data,
values_dofs +
- 2 * size_deg);
+ 2 * n_dofs);
// grad xy
eval1.template gradients<1, false, false>(hessians_quad +
if (integration_flag & EvaluationFlags::gradients)
eval0.template gradients<0, false, true>(scratch_data,
values_dofs +
- size_deg);
+ n_dofs);
else
eval0.template gradients<0, false, false>(scratch_data,
values_dofs +
- size_deg);
+ n_dofs);
// grad yz
eval1.template gradients<1, false, false>(hessians_quad +
5 * n_q_points,
scratch_data);
eval0.template values<0, false, true>(scratch_data,
- values_dofs +
- size_deg);
+ values_dofs + n_dofs);
break;
case 2:
// grad yy
eval0.template values<0, false, false>(
- hessians_quad + n_q_points, values_dofs + 2 * size_deg);
+ hessians_quad + n_q_points, values_dofs + 2 * n_dofs);
// grad xy
if (integration_flag & EvaluationFlags::gradients)
eval0.template gradients<0, false, true>(
- hessians_quad + 2 * n_q_points, values_dofs + size_deg);
+ hessians_quad + 2 * n_q_points, values_dofs + n_dofs);
else
eval0.template gradients<0, false, false>(
- hessians_quad + 2 * n_q_points, values_dofs + size_deg);
+ hessians_quad + 2 * n_q_points, values_dofs + n_dofs);
break;
case 1:
values_dofs[2] = hessians_quad[0];
default:
AssertThrow(false, ExcNotImplemented());
}
- values_dofs += 3 * size_deg;
+ values_dofs += 3 * n_dofs;
hessians_quad += dim * (dim + 1) / 2 * n_q_points;
}
}
private:
template <bool do_evaluate, bool add_into_output, int face_direction = 0>
- static DEAL_II_ALWAYS_INLINE void
+ static void
interpolate_generic(const unsigned int n_components,
const Number * input,
Number * output,
run(const unsigned int n_components,
const EvaluationFlags::EvaluationFlags evaluation_flag,
const Number * values_dofs,
- FEEvaluationBaseData<dim, typename Number::value_type, true, Number>
- &eval)
+ FEEvaluationData<dim, Number, true> & eval)
{
const auto & data = eval.get_shape_info();
const auto & shape_data = data.data.front();
if (data.element_type == MatrixFreeFunctions::tensor_none)
{
- const unsigned int n_dofs = data.dofs_per_component_on_cell;
- const unsigned int n_q_points = data.n_q_points_faces[face_no];
+ const std::size_t n_dofs = data.dofs_per_component_on_cell;
+ const std::size_t n_q_points = data.n_q_points_faces[face_no];
using Eval =
EvaluatorTensorProduct<evaluate_general, 1, 0, 0, Number, Number>;
fe_degree > -1 ? Utilities::pow(fe_degree + 1, dim - 1) :
Utilities::pow(shape_data.fe_degree + 1, dim - 1);
+ // Note: we always keep storage of values, 1st and 2nd derivatives in an
+ // array, so reserve space for all three here
Number *temp = eval.get_scratch_data().begin();
Number *scratch_data = temp + 3 * n_components * dofs_per_face;
run(const unsigned int n_components,
const EvaluationFlags::EvaluationFlags integration_flag,
Number * values_dofs,
- FEEvaluationBaseData<dim, typename Number::value_type, true, Number>
- &eval)
+ FEEvaluationData<dim, Number, true> & eval)
{
const auto & data = eval.get_shape_info();
const auto & shape_data = data.data.front();
if (data.element_type == MatrixFreeFunctions::tensor_none)
{
- const unsigned int n_dofs = data.dofs_per_component_on_cell;
- const unsigned int n_q_points = data.n_q_points_faces[face_no];
+ const std::size_t n_dofs = data.dofs_per_component_on_cell;
+ const std::size_t n_q_points = data.n_q_points_faces[face_no];
using Eval =
EvaluatorTensorProduct<evaluate_general, 1, 0, 0, Number, Number>;
{
template <int fe_degree, int n_q_points_1d>
static bool
- run(const unsigned int n_components,
- const EvaluationFlags::EvaluationFlags evaluation_flag,
- const Number2 * src_ptr,
- const std::vector<ArrayView<const Number>> *sm_ptr,
- FEEvaluationBaseData<dim, Number, true, VectorizedArrayType> &eval)
+ run(const unsigned int n_components,
+ const EvaluationFlags::EvaluationFlags evaluation_flag,
+ const Number2 * src_ptr,
+ const std::vector<ArrayView<const Number>> * sm_ptr,
+ FEEvaluationData<dim, VectorizedArrayType, true> &eval)
{
Assert(fe_degree > -1, ExcInternalError());
Assert(eval.get_shape_info().element_type <=
{
template <int fe_degree, int n_q_points_1d>
static bool
- run(const unsigned int n_components,
- const EvaluationFlags::EvaluationFlags integration_flag,
- Number2 * dst_ptr,
- const std::vector<ArrayView<const Number2>> *sm_ptr,
- FEEvaluationBaseData<dim, Number, true, VectorizedArrayType> &eval)
+ run(const unsigned int n_components,
+ const EvaluationFlags::EvaluationFlags integration_flag,
+ Number2 * dst_ptr,
+ const std::vector<ArrayView<const Number2>> * sm_ptr,
+ FEEvaluationData<dim, VectorizedArrayType, true> &eval)
{
Assert(fe_degree > -1, ExcInternalError());
Assert(eval.get_shape_info().element_type <=
/**
* This struct implements the action of the inverse mass matrix operation
- * using an FEEvaluationBaseData argument.
+ * using an FEEvaluationData argument.
*/
template <int dim, typename Number>
struct CellwiseInverseMassMatrixImplBasic
{
template <int fe_degree, int = 0>
static bool
- run(const unsigned int n_components,
- const FEEvaluationBaseData<dim,
- typename Number::value_type,
- false,
- Number> &fe_eval,
- const Number * in_array,
- Number * out_array,
+ run(const unsigned int n_components,
+ const FEEvaluationData<dim, Number, false> &fe_eval,
+ const Number * in_array,
+ Number * out_array,
typename std::enable_if<fe_degree != -1>::type * = nullptr)
{
constexpr unsigned int dofs_per_component =
template <int fe_degree, int = 0>
static bool
- run(const unsigned int n_components,
- const FEEvaluationBaseData<dim,
- typename Number::value_type,
- false,
- Number> &fe_eval,
- const Number * in_array,
- Number * out_array,
+ run(const unsigned int n_components,
+ const FEEvaluationData<dim, Number, false> &fe_eval,
+ const Number * in_array,
+ Number * out_array,
typename std::enable_if<fe_degree == -1>::type * = nullptr)
{
static_assert(fe_degree == -1, "Only usable for degree -1");
/**
* This struct implements the action of the inverse mass matrix operation
- * using an FEEvaluationBaseData argument.
+ * using an FEEvaluationData argument.
*/
template <int dim, typename Number>
struct CellwiseInverseMassMatrixImplFlexible
/**
* This struct implements the action of the inverse mass matrix operation
- * using an FEEvaluationBaseData argument.
+ * using an FEEvaluationData argument.
*/
template <int dim, typename Number>
struct CellwiseInverseMassMatrixImplTransformFromQPoints
{
template <int fe_degree, int n_q_points_1d>
static bool
- run(const unsigned int n_desired_components,
- const FEEvaluationBaseData<dim,
- typename Number::value_type,
- false,
- Number> &fe_eval,
- const Number * in_array,
- Number * out_array)
+ run(const unsigned int n_desired_components,
+ const FEEvaluationData<dim, Number, false> &fe_eval,
+ const Number * in_array,
+ Number * out_array)
{
static const bool do_inplace =
fe_degree > -1 && (fe_degree + 1 == n_q_points_1d);
fe_eval.get_shape_info().data.front().inverse_shape_values_eo :
fe_eval.get_shape_info().data.front().inverse_shape_values;
- const unsigned int dofs_per_component =
+ const std::size_t dofs_per_component =
do_inplace ? Utilities::pow(fe_degree + 1, dim) :
fe_eval.get_shape_info().dofs_per_component_on_cell;
- const unsigned int n_q_points = do_inplace ?
- Utilities::pow(fe_degree + 1, dim) :
- fe_eval.get_shape_info().n_q_points;
+ const std::size_t n_q_points = do_inplace ?
+ Utilities::pow(fe_degree + 1, dim) :
+ fe_eval.get_shape_info().n_q_points;
internal::EvaluatorTensorProduct<do_inplace ? internal::evaluate_evenodd :
internal::evaluate_general,
template <int dim, int fe_degree, int n_q_points_1d, typename Number>
struct SelectEvaluator
{
- using ScalarNumber =
- typename internal::VectorizedArrayTrait<Number>::value_type;
-
/**
* Chooses an appropriate evaluation strategy for the evaluate function, i.e.
* this calls internal::FEEvaluationImpl::evaluate(),
evaluate(const unsigned int n_components,
const EvaluationFlags::EvaluationFlags evaluation_flag,
const Number * values_dofs,
- FEEvaluationBaseData<dim, ScalarNumber, false, Number> &eval);
+ FEEvaluationData<dim, Number, false> & eval);
/**
* Chooses an appropriate evaluation strategy for the integrate function, i.e.
integrate(const unsigned int n_components,
const EvaluationFlags::EvaluationFlags integration_flag,
Number * values_dofs,
- FEEvaluationBaseData<dim, ScalarNumber, false, Number> &eval,
+ FEEvaluationData<dim, Number, false> & eval,
const bool sum_into_values_array = false);
};
template <int dim, int fe_degree, int n_q_points_1d, typename Number>
inline void
SelectEvaluator<dim, fe_degree, n_q_points_1d, Number>::evaluate(
- const unsigned int n_components,
- const EvaluationFlags::EvaluationFlags evaluation_flag,
- const Number * values_dofs,
- FEEvaluationBaseData<dim, ScalarNumber, false, Number> &eval)
+ const unsigned int n_components,
+ const EvaluationFlags::EvaluationFlags evaluation_flag,
+ const Number * values_dofs,
+ FEEvaluationData<dim, Number, false> & eval)
{
Assert(fe_degree >= 0 && n_q_points_1d > 0, ExcInternalError());
template <int dim, int fe_degree, int n_q_points_1d, typename Number>
inline void
SelectEvaluator<dim, fe_degree, n_q_points_1d, Number>::integrate(
- const unsigned int n_components,
- const EvaluationFlags::EvaluationFlags integration_flag,
- Number * values_dofs,
- FEEvaluationBaseData<dim, ScalarNumber, false, Number> &eval,
- const bool sum_into_values_array)
+ const unsigned int n_components,
+ const EvaluationFlags::EvaluationFlags integration_flag,
+ Number * values_dofs,
+ FEEvaluationData<dim, Number, false> & eval,
+ const bool sum_into_values_array)
{
Assert(fe_degree >= 0 && n_q_points_1d > 0, ExcInternalError());
DEAL_II_NAMESPACE_OPEN
-template <int, typename, bool, typename>
-class FEEvaluationBaseData;
+template <int, typename, bool>
+class FEEvaluationData;
namespace internal
{
- template <int dim, typename Number, typename VectorizedArrayType>
+ template <int dim, typename Number>
struct FEEvaluationFactory
{
static void
- evaluate(
- const unsigned int n_components,
- const EvaluationFlags::EvaluationFlags evaluation_flag,
- const VectorizedArrayType * values_dofs,
- FEEvaluationBaseData<dim, Number, false, VectorizedArrayType> &eval);
+ evaluate(const unsigned int n_components,
+ const EvaluationFlags::EvaluationFlags evaluation_flag,
+ const Number * values_dofs,
+ FEEvaluationData<dim, Number, false> & eval);
static void
- integrate(
- const unsigned int n_components,
- const EvaluationFlags::EvaluationFlags integration_flag,
- VectorizedArrayType * values_dofs,
- FEEvaluationBaseData<dim, Number, false, VectorizedArrayType> &eval,
- const bool sum_into_values_array);
+ integrate(const unsigned int n_components,
+ const EvaluationFlags::EvaluationFlags integration_flag,
+ Number * values_dofs,
+ FEEvaluationData<dim, Number, false> & eval,
+ const bool sum_into_values_array);
static bool
fast_evaluation_supported(const unsigned int given_degree,
- template <int dim,
- typename Number,
- typename VectorizedArrayType = VectorizedArray<Number>>
+ template <int dim, typename Number>
struct FEFaceEvaluationFactory
{
static void
- evaluate(
- const unsigned int n_components,
- const EvaluationFlags::EvaluationFlags evaluation_flag,
- const VectorizedArrayType * values_dofs,
- FEEvaluationBaseData<dim, Number, true, VectorizedArrayType> &eval);
+ evaluate(const unsigned int n_components,
+ const EvaluationFlags::EvaluationFlags evaluation_flag,
+ const Number * values_dofs,
+ FEEvaluationData<dim, Number, true> & eval);
static void
- integrate(
- const unsigned int n_components,
- const EvaluationFlags::EvaluationFlags integration_flag,
- VectorizedArrayType * values_dofs,
- FEEvaluationBaseData<dim, Number, true, VectorizedArrayType> &eval);
-
- static void
- gather_evaluate(
- const unsigned int n_components,
- const EvaluationFlags::EvaluationFlags evaluation_flag,
- const Number * src_ptr,
- const std::vector<ArrayView<const Number>> *sm_ptr,
- FEEvaluationBaseData<dim, Number, true, VectorizedArrayType> &eval);
-
- static void
- integrate_scatter(
- const unsigned int n_components,
- const EvaluationFlags::EvaluationFlags integration_flag,
- Number * dst_ptr,
- const std::vector<ArrayView<const Number>> *sm_ptr,
- FEEvaluationBaseData<dim, Number, true, VectorizedArrayType> &eval);
+ integrate(const unsigned int n_components,
+ const EvaluationFlags::EvaluationFlags integration_flag,
+ Number * values_dofs,
+ FEEvaluationData<dim, Number, true> & eval);
static bool
fast_evaluation_supported(const unsigned int given_degree,
const unsigned int n_q_points_1d);
};
+ template <int dim, typename Number, typename VectorizedArrayType>
+ struct FEFaceEvaluationGatherFactory
+ {
+ static void
+ evaluate(const unsigned int n_components,
+ const EvaluationFlags::EvaluationFlags evaluation_flag,
+ const Number * src_ptr,
+ const std::vector<ArrayView<const Number>> * sm_ptr,
+ FEEvaluationData<dim, VectorizedArrayType, true> &eval);
+
+ static void
+ integrate(const unsigned int n_components,
+ const EvaluationFlags::EvaluationFlags integration_flag,
+ Number * dst_ptr,
+ const std::vector<ArrayView<const Number>> *sm_ptr,
+ FEEvaluationData<dim, VectorizedArrayType, true> &eval);
+ };
+
- template <int dim,
- typename Number,
- typename VectorizedArrayType = VectorizedArray<Number>>
+ template <int dim, typename Number>
struct CellwiseInverseMassFactory
{
static void
- apply(const unsigned int n_components,
- const FEEvaluationBaseData<dim, Number, false, VectorizedArrayType>
- & fe_eval,
- const VectorizedArrayType *in_array,
- VectorizedArrayType * out_array);
+ apply(const unsigned int n_components,
+ const FEEvaluationData<dim, Number, false> &fe_eval,
+ const Number * in_array,
+ Number * out_array);
static void
- apply(const unsigned int n_components,
- const unsigned int fe_degree,
- const AlignedVector<VectorizedArrayType> &inverse_shape,
- const AlignedVector<VectorizedArrayType> &inverse_coefficients,
- const VectorizedArrayType * in_array,
- VectorizedArrayType * out_array);
+ apply(const unsigned int n_components,
+ const unsigned int fe_degree,
+ const AlignedVector<Number> &inverse_shape,
+ const AlignedVector<Number> &inverse_coefficients,
+ const Number * in_array,
+ Number * out_array);
static void
transform_from_q_points_to_basis(
- const unsigned int n_components,
- const FEEvaluationBaseData<dim, Number, false, VectorizedArrayType>
- & fe_eval,
- const VectorizedArrayType *in_array,
- VectorizedArrayType * out_array);
+ const unsigned int n_components,
+ const FEEvaluationData<dim, Number, false> &fe_eval,
+ const Number * in_array,
+ Number * out_array);
};
template <int dim,
- template <int dim, typename Number, typename VectorizedArrayType>
+ template <int dim, typename Number>
void
- FEEvaluationFactory<dim, Number, VectorizedArrayType>::evaluate(
+ FEEvaluationFactory<dim, Number>::evaluate(
const unsigned int n_components,
const EvaluationFlags::EvaluationFlags evaluation_flag,
- const VectorizedArrayType * values_dofs,
- FEEvaluationBaseData<dim, Number, false, VectorizedArrayType> &eval)
+ const Number * values_dofs,
+ FEEvaluationData<dim, Number, false> & eval)
{
- instantiation_helper_run<
- 1,
- FEEvaluationImplEvaluateSelector<dim, VectorizedArrayType>>(
+ instantiation_helper_run<1, FEEvaluationImplEvaluateSelector<dim, Number>>(
eval.get_shape_info().data[0].fe_degree,
eval.get_shape_info().data[0].n_q_points_1d,
n_components,
- template <int dim, typename Number, typename VectorizedArrayType>
+ template <int dim, typename Number>
void
- FEEvaluationFactory<dim, Number, VectorizedArrayType>::integrate(
+ FEEvaluationFactory<dim, Number>::integrate(
const unsigned int n_components,
const EvaluationFlags::EvaluationFlags integration_flag,
- VectorizedArrayType * values_dofs,
- FEEvaluationBaseData<dim, Number, false, VectorizedArrayType> &eval,
- const bool sum_into_values_array)
+ Number * values_dofs,
+ FEEvaluationData<dim, Number, false> & eval,
+ const bool sum_into_values_array)
{
- instantiation_helper_run<
- 1,
- FEEvaluationImplIntegrateSelector<dim, VectorizedArrayType>>(
+ instantiation_helper_run<1, FEEvaluationImplIntegrateSelector<dim, Number>>(
eval.get_shape_info().data[0].fe_degree,
eval.get_shape_info().data[0].n_q_points_1d,
n_components,
- template <int dim, typename Number, typename VectorizedArrayType>
+ template <int dim, typename Number>
bool
- FEEvaluationFactory<dim, Number, VectorizedArrayType>::
- fast_evaluation_supported(const unsigned int given_degree,
- const unsigned int n_q_points_1d)
+ FEEvaluationFactory<dim, Number>::fast_evaluation_supported(
+ const unsigned int given_degree,
+ const unsigned int n_q_points_1d)
{
return instantiation_helper_run<1, FastEvaluationSupported>(given_degree,
n_q_points_1d);
- template <int dim, typename Number, typename VectorizedArrayType>
+ template <int dim, typename Number>
void
- FEFaceEvaluationFactory<dim, Number, VectorizedArrayType>::evaluate(
+ FEFaceEvaluationFactory<dim, Number>::evaluate(
const unsigned int n_components,
const EvaluationFlags::EvaluationFlags evaluation_flag,
- const VectorizedArrayType * values_dofs,
- FEEvaluationBaseData<dim, Number, true, VectorizedArrayType> &eval)
+ const Number * values_dofs,
+ FEEvaluationData<dim, Number, true> & eval)
{
- instantiation_helper_run<
- 1,
- FEFaceEvaluationImplEvaluateSelector<dim, VectorizedArrayType>>(
+ instantiation_helper_run<1,
+ FEFaceEvaluationImplEvaluateSelector<dim, Number>>(
eval.get_shape_info().data[0].fe_degree,
eval.get_shape_info().data[0].n_q_points_1d,
n_components,
- template <int dim, typename Number, typename VectorizedArrayType>
+ template <int dim, typename Number>
void
- FEFaceEvaluationFactory<dim, Number, VectorizedArrayType>::integrate(
+ FEFaceEvaluationFactory<dim, Number>::integrate(
const unsigned int n_components,
const EvaluationFlags::EvaluationFlags integration_flag,
- VectorizedArrayType * values_dofs,
- FEEvaluationBaseData<dim, Number, true, VectorizedArrayType> &eval)
+ Number * values_dofs,
+ FEEvaluationData<dim, Number, true> & eval)
{
instantiation_helper_run<
1,
- FEFaceEvaluationImplIntegrateSelector<dim, VectorizedArrayType>>(
+ FEFaceEvaluationImplIntegrateSelector<dim, Number>>(
eval.get_shape_info().data[0].fe_degree,
eval.get_shape_info().data[0].n_q_points_1d,
n_components,
template <int dim, typename Number, typename VectorizedArrayType>
void
- FEFaceEvaluationFactory<dim, Number, VectorizedArrayType>::gather_evaluate(
- const unsigned int n_components,
- const EvaluationFlags::EvaluationFlags evaluation_flag,
- const Number * src_ptr,
- const std::vector<ArrayView<const Number>> *sm_ptr,
- FEEvaluationBaseData<dim, Number, true, VectorizedArrayType> &eval)
+ FEFaceEvaluationGatherFactory<dim, Number, VectorizedArrayType>::evaluate(
+ const unsigned int n_components,
+ const EvaluationFlags::EvaluationFlags evaluation_flag,
+ const Number * src_ptr,
+ const std::vector<ArrayView<const Number>> * sm_ptr,
+ FEEvaluationData<dim, VectorizedArrayType, true> &eval)
{
instantiation_helper_run<
1,
template <int dim, typename Number, typename VectorizedArrayType>
void
- FEFaceEvaluationFactory<dim, Number, VectorizedArrayType>::integrate_scatter(
- const unsigned int n_components,
- const EvaluationFlags::EvaluationFlags integration_flag,
- Number * dst_ptr,
- const std::vector<ArrayView<const Number>> *sm_ptr,
- FEEvaluationBaseData<dim, Number, true, VectorizedArrayType> &eval)
+ FEFaceEvaluationGatherFactory<dim, Number, VectorizedArrayType>::integrate(
+ const unsigned int n_components,
+ const EvaluationFlags::EvaluationFlags integration_flag,
+ Number * dst_ptr,
+ const std::vector<ArrayView<const Number>> * sm_ptr,
+ FEEvaluationData<dim, VectorizedArrayType, true> &eval)
{
instantiation_helper_run<
1,
- template <int dim, typename Number, typename VectorizedArrayType>
+ template <int dim, typename Number>
bool
- FEFaceEvaluationFactory<dim, Number, VectorizedArrayType>::
- fast_evaluation_supported(const unsigned int given_degree,
- const unsigned int n_q_points_1d)
+ FEFaceEvaluationFactory<dim, Number>::fast_evaluation_supported(
+ const unsigned int given_degree,
+ const unsigned int n_q_points_1d)
{
return instantiation_helper_run<1, FastEvaluationSupported>(given_degree,
n_q_points_1d);
- template <int dim, typename Number, typename VectorizedArrayType>
+ template <int dim, typename Number>
void
- CellwiseInverseMassFactory<dim, Number, VectorizedArrayType>::apply(
- const unsigned int n_components,
- const FEEvaluationBaseData<dim, Number, false, VectorizedArrayType>
- & fe_eval,
- const VectorizedArrayType *in_array,
- VectorizedArrayType * out_array)
+ CellwiseInverseMassFactory<dim, Number>::apply(
+ const unsigned int n_components,
+ const FEEvaluationData<dim, Number, false> &fe_eval,
+ const Number * in_array,
+ Number * out_array)
{
const unsigned int fe_degree = fe_eval.get_shape_info().data[0].fe_degree;
- instantiation_helper_run<
- 1,
- CellwiseInverseMassMatrixImplBasic<dim, VectorizedArrayType>>(
+ instantiation_helper_run<1,
+ CellwiseInverseMassMatrixImplBasic<dim, Number>>(
fe_degree, fe_degree + 1, n_components, fe_eval, in_array, out_array);
}
- template <int dim, typename Number, typename VectorizedArrayType>
+ template <int dim, typename Number>
void
- CellwiseInverseMassFactory<dim, Number, VectorizedArrayType>::apply(
- const unsigned int n_components,
- const unsigned int fe_degree,
- const AlignedVector<VectorizedArrayType> &inverse_shape,
- const AlignedVector<VectorizedArrayType> &inverse_coefficients,
- const VectorizedArrayType * in_array,
- VectorizedArrayType * out_array)
+ CellwiseInverseMassFactory<dim, Number>::apply(
+ const unsigned int n_components,
+ const unsigned int fe_degree,
+ const AlignedVector<Number> &inverse_shape,
+ const AlignedVector<Number> &inverse_coefficients,
+ const Number * in_array,
+ Number * out_array)
{
instantiation_helper_run<
1,
- CellwiseInverseMassMatrixImplFlexible<dim, VectorizedArrayType>>(
- fe_degree,
- fe_degree + 1,
- n_components,
- inverse_shape,
- inverse_coefficients,
- in_array,
- out_array);
+ CellwiseInverseMassMatrixImplFlexible<dim, Number>>(fe_degree,
+ fe_degree + 1,
+ n_components,
+ inverse_shape,
+ inverse_coefficients,
+ in_array,
+ out_array);
}
- template <int dim, typename Number, typename VectorizedArrayType>
+ template <int dim, typename Number>
void
- CellwiseInverseMassFactory<dim, Number, VectorizedArrayType>::
- transform_from_q_points_to_basis(
- const unsigned int n_components,
- const FEEvaluationBaseData<dim, Number, false, VectorizedArrayType>
- & fe_eval,
- const VectorizedArrayType *in_array,
- VectorizedArrayType * out_array)
+ CellwiseInverseMassFactory<dim, Number>::transform_from_q_points_to_basis(
+ const unsigned int n_components,
+ const FEEvaluationData<dim, Number, false> &fe_eval,
+ const Number * in_array,
+ Number * out_array)
{
const unsigned int fe_degree = fe_eval.get_shape_info().data[0].fe_degree;
const unsigned int n_q_points_1d =
fe_eval.get_shape_info().data[0].n_q_points_1d;
instantiation_helper_run<
1,
- CellwiseInverseMassMatrixImplTransformFromQPoints<dim,
- VectorizedArrayType>>(
+ CellwiseInverseMassMatrixImplTransformFromQPoints<dim, Number>>(
fe_degree, n_q_points_1d, n_components, fe_eval, in_array, out_array);
}
#include <deal.II/matrix_free/evaluation_kernels.h>
#include <deal.II/matrix_free/evaluation_selector.h>
#include <deal.II/matrix_free/evaluation_template_factory.h>
-#include <deal.II/matrix_free/fe_evaluation_base_data.h>
+#include <deal.II/matrix_free/fe_evaluation_data.h>
#include <deal.II/matrix_free/mapping_data_on_the_fly.h>
#include <deal.II/matrix_free/matrix_free.h>
#include <deal.II/matrix_free/shape_info.h>
* FEEvaluationBase::distribute_local_to_global() functions, as well as
* methods to access values and gradients of finite element functions. It also
* inherits the geometry access functions provided by the class
- * FEEvaluationBaseData.
+ * FEEvaluationData.
*
* This class has five template arguments:
*
bool is_face,
typename VectorizedArrayType>
class FEEvaluationBase
- : public FEEvaluationBaseData<dim, Number, is_face, VectorizedArrayType>
+ : public FEEvaluationData<dim, VectorizedArrayType, is_face>
{
public:
using number_type = Number;
* possibly within the element if the evaluate/integrate routines are
* combined inside user code (e.g. for computing cell matrices).
*
- * The optional FEEvaluationBaseData object allows several
+ * The optional FEEvaluationData object allows several
* FEEvaluation objects to share the geometry evaluation, i.e., the
* underlying mapping and quadrature points do only need to be evaluated
* once. This only works if the quadrature formulas are the same. Otherwise,
const Quadrature<1> & quadrature,
const UpdateFlags update_flags,
const unsigned int first_selected_component,
- const FEEvaluationBaseData<dim, Number, is_face, VectorizedArrayType>
- *other);
+ const FEEvaluationData<dim, VectorizedArrayType, is_face> *other);
/**
* Copy constructor. If FEEvaluationBase was constructed from a mapping, fe,
const Quadrature<1> & quadrature,
const UpdateFlags update_flags,
const unsigned int first_selected_component,
- const FEEvaluationBaseData<dim, Number, is_face, VectorizedArrayType>
- *other);
+ const FEEvaluationData<dim, VectorizedArrayType, is_face> *other);
/**
* Copy constructor
const Quadrature<1> & quadrature,
const UpdateFlags update_flags,
const unsigned int first_selected_component,
- const FEEvaluationBaseData<dim, Number, is_face, VectorizedArrayType>
- *other);
+ const FEEvaluationData<dim, VectorizedArrayType, is_face> *other);
/**
* Copy constructor
const Quadrature<1> & quadrature,
const UpdateFlags update_flags,
const unsigned int first_selected_component,
- const FEEvaluationBaseData<dim, Number, is_face, VectorizedArrayType>
- *other);
+ const FEEvaluationData<dim, VectorizedArrayType, is_face> *other);
/**
* Copy constructor
const Quadrature<1> & quadrature,
const UpdateFlags update_flags,
const unsigned int first_selected_component,
- const FEEvaluationBaseData<1, Number, is_face, VectorizedArrayType> *other);
+ const FEEvaluationData<1, VectorizedArrayType, is_face> *other);
/**
* Copy constructor
* use the FEEvaluation object in %parallel to the given one because
* otherwise the intended sharing may create race conditions.
*/
- FEEvaluation(
- const FiniteElement<dim> & fe,
- const FEEvaluationBaseData<dim, Number, false, VectorizedArrayType> &other,
- const unsigned int first_selected_component = 0);
+ FEEvaluation(const FiniteElement<dim> & fe,
+ const FEEvaluationData<dim, VectorizedArrayType, false> &other,
+ const unsigned int first_selected_component = 0);
/**
* Copy constructor. If FEEvaluationBase was constructed from a mapping, fe,
const internal::MatrixFreeFunctions::ShapeInfo<VectorizedArrayType> *,
const internal::MatrixFreeFunctions::DoFInfo *,
const internal::MatrixFreeFunctions::
- MappingInfoStorage<dim - is_face, dim, Number, VectorizedArrayType> *,
+ MappingInfoStorage<dim - is_face, dim, VectorizedArrayType> *,
unsigned int,
unsigned int>
get_shape_info_and_indices(
const unsigned int active_fe_index,
const unsigned int active_quad_index,
const unsigned int face_type)
- : FEEvaluationBaseData<dim, Number, is_face, VectorizedArrayType>(
+ : FEEvaluationData<dim, VectorizedArrayType, is_face>(
internal::get_shape_info_and_indices<is_face>(data_in,
dof_no,
first_selected_component,
const Quadrature<1> & quadrature,
const UpdateFlags update_flags,
const unsigned int first_selected_component,
- const FEEvaluationBaseData<dim, Number, is_face, VectorizedArrayType>
- *other)
- : FEEvaluationBaseData<dim, Number, is_face, VectorizedArrayType>(
+ const FEEvaluationData<dim, VectorizedArrayType, is_face> *other)
+ : FEEvaluationData<dim, VectorizedArrayType, is_face>(
other != nullptr &&
other->mapped_geometry->get_quadrature() == quadrature ?
other->mapped_geometry :
- std::make_shared<
- internal::MatrixFreeFunctions::
- MappingDataOnTheFly<dim, Number, VectorizedArrayType>>(
+ std::make_shared<internal::MatrixFreeFunctions::
+ MappingDataOnTheFly<dim, VectorizedArrayType>>(
mapping,
quadrature,
update_flags),
Number,
is_face,
VectorizedArrayType> &other)
- : FEEvaluationBaseData<dim, Number, is_face, VectorizedArrayType>(other)
+ : FEEvaluationData<dim, VectorizedArrayType, is_face>(other)
, scratch_data_array(other.matrix_info == nullptr ?
new AlignedVector<VectorizedArrayType>() :
other.matrix_info->acquire_scratch_data())
*other.data);
// Create deep copy of mapped geometry for use in parallel
- this->mapped_geometry = std::make_shared<
- internal::MatrixFreeFunctions::
- MappingDataOnTheFly<dim, Number, VectorizedArrayType>>(
- other.mapped_geometry->get_fe_values().get_mapping(),
- other.mapped_geometry->get_quadrature(),
- other.mapped_geometry->get_fe_values().get_update_flags());
+ this->mapped_geometry =
+ std::make_shared<internal::MatrixFreeFunctions::
+ MappingDataOnTheFly<dim, VectorizedArrayType>>(
+ other.mapped_geometry->get_fe_values().get_mapping(),
+ other.mapped_geometry->get_quadrature(),
+ other.mapped_geometry->get_fe_values().get_update_flags());
this->mapping_data = &this->mapped_geometry->get_data_storage();
this->cell = 0;
matrix_info->release_scratch_data(scratch_data_array);
}
- this->FEEvaluationBaseData<dim, Number, is_face, VectorizedArrayType>::
- operator=(other);
+ this->FEEvaluationData<dim, VectorizedArrayType, is_face>::operator=(other);
matrix_info = other.matrix_info;
scratch_data_array = new AlignedVector<VectorizedArrayType>();
// Create deep copy of mapped geometry for use in parallel
- this->mapped_geometry = std::make_shared<
- internal::MatrixFreeFunctions::
- MappingDataOnTheFly<dim, Number, VectorizedArrayType>>(
- other.mapped_geometry->get_fe_values().get_mapping(),
- other.mapped_geometry->get_quadrature(),
- other.mapped_geometry->get_fe_values().get_update_flags());
+ this->mapped_geometry =
+ std::make_shared<internal::MatrixFreeFunctions::
+ MappingDataOnTheFly<dim, VectorizedArrayType>>(
+ other.mapped_geometry->get_fe_values().get_mapping(),
+ other.mapped_geometry->get_quadrature(),
+ other.mapped_geometry->get_fe_values().get_update_flags());
this->cell = 0;
this->mapping_data = &this->mapped_geometry->get_data_storage();
this->jacobian =
const Quadrature<1> & quadrature,
const UpdateFlags update_flags,
const unsigned int first_selected_component,
- const FEEvaluationBaseData<dim, Number, is_face, VectorizedArrayType>
- *other)
+ const FEEvaluationData<dim, VectorizedArrayType, is_face> *other)
: FEEvaluationBase<dim, n_components_, Number, is_face, VectorizedArrayType>(
mapping,
fe,
const Quadrature<1> & quadrature,
const UpdateFlags update_flags,
const unsigned int first_selected_component,
- const FEEvaluationBaseData<dim, Number, is_face, VectorizedArrayType>
- *other)
+ const FEEvaluationData<dim, VectorizedArrayType, is_face> *other)
: FEEvaluationBase<dim, 1, Number, is_face, VectorizedArrayType>(
mapping,
fe,
const Quadrature<1> & quadrature,
const UpdateFlags update_flags,
const unsigned int first_selected_component,
- const FEEvaluationBaseData<dim, Number, is_face, VectorizedArrayType>
- *other)
+ const FEEvaluationData<dim, VectorizedArrayType, is_face> *other)
: FEEvaluationBase<dim, dim, Number, is_face, VectorizedArrayType>(
mapping,
fe,
const Quadrature<1> & quadrature,
const UpdateFlags update_flags,
const unsigned int first_selected_component,
- const FEEvaluationBaseData<1, Number, is_face, VectorizedArrayType> *other)
+ const FEEvaluationData<1, VectorizedArrayType, is_face> *other)
: FEEvaluationBase<1, 1, Number, is_face, VectorizedArrayType>(
mapping,
fe,
n_components_,
Number,
VectorizedArrayType>::
- FEEvaluation(
- const FiniteElement<dim> & fe,
- const FEEvaluationBaseData<dim, Number, false, VectorizedArrayType> &other,
- const unsigned int first_selected_component)
+ FEEvaluation(const FiniteElement<dim> & fe,
+ const FEEvaluationData<dim, VectorizedArrayType, false> &other,
+ const unsigned int first_selected_component)
: BaseClass(other.mapped_geometry->get_fe_values().get_mapping(),
fe,
other.mapped_geometry->get_quadrature(),
SelectEvaluator<dim, fe_degree, n_q_points_1d, VectorizedArrayType>::
evaluate(n_components, evaluation_flag_actual, values_array, *this);
else
- internal::FEEvaluationFactory<dim, Number, VectorizedArrayType>::evaluate(
+ internal::FEEvaluationFactory<dim, VectorizedArrayType>::evaluate(
n_components,
evaluation_flag_actual,
const_cast<VectorizedArrayType *>(values_array),
VectorizedArrayType *vec_values =
reinterpret_cast<VectorizedArrayType *>(
destination.begin() +
- dof_info->dof_indices_contiguous
+ dof_info.dof_indices_contiguous
[internal::MatrixFreeFunctions::DoFInfo::dof_access_cell]
[cell * VectorizedArrayType::size()] +
- dof_info->component_dof_indices_offset
+ dof_info.component_dof_indices_offset
[phi.get_active_fe_index()]
[phi.get_first_selected_component()] *
VectorizedArrayType::size());
*this,
sum_into_values_array);
else
- internal::FEEvaluationFactory<dim, Number, VectorizedArrayType>::integrate(
+ internal::FEEvaluationFactory<dim, VectorizedArrayType>::integrate(
n_components,
integration_flag_actual,
values_array,
values_array,
*this);
else
- internal::FEFaceEvaluationFactory<dim, Number, VectorizedArrayType>::
- evaluate(n_components, evaluation_flag_actual, values_array, *this);
+ internal::FEFaceEvaluationFactory<dim, VectorizedArrayType>::evaluate(
+ n_components, evaluation_flag_actual, values_array, *this);
# ifdef DEBUG
if (evaluation_flag_actual & EvaluationFlags::values)
values_array,
*this);
else
- internal::FEFaceEvaluationFactory<dim, Number, VectorizedArrayType>::
- integrate(n_components, integration_flag_actual, values_array, *this);
+ internal::FEFaceEvaluationFactory<dim, VectorizedArrayType>::integrate(
+ n_components, integration_flag_actual, values_array, *this);
}
shared_vector_data,
*this);
else
- internal::FEFaceEvaluationFactory<dim, Number, VectorizedArrayType>::
- gather_evaluate(n_components,
- evaluation_flag,
- internal::get_beginning<Number>(input_vector),
- shared_vector_data,
- *this);
+ internal::FEFaceEvaluationGatherFactory<
+ dim,
+ Number,
+ VectorizedArrayType>::evaluate(n_components,
+ evaluation_flag,
+ internal::get_beginning<Number>(
+ input_vector),
+ shared_vector_data,
+ *this);
}
else
{
shared_vector_data,
*this);
else
- internal::FEFaceEvaluationFactory<dim, Number, VectorizedArrayType>::
- integrate_scatter(n_components,
- integration_flag,
- internal::get_beginning<Number>(destination),
- shared_vector_data,
- *this);
+ internal::FEFaceEvaluationGatherFactory<
+ dim,
+ Number,
+ VectorizedArrayType>::integrate(n_components,
+ integration_flag,
+ internal::get_beginning<Number>(
+ destination),
+ shared_vector_data,
+ *this);
}
else
{
const unsigned int give_n_q_points_1d)
{
return fe_degree == -1 ?
- internal::FEEvaluationFactory<dim, Number, VectorizedArrayType>::
+ internal::FEEvaluationFactory<dim, VectorizedArrayType>::
fast_evaluation_supported(given_degree, give_n_q_points_1d) :
true;
}
const unsigned int give_n_q_points_1d)
{
return fe_degree == -1 ?
- internal::FEFaceEvaluationFactory<dim, Number, VectorizedArrayType>::
+ internal::FEFaceEvaluationFactory<dim, VectorizedArrayType>::
fast_evaluation_supported(given_degree, give_n_q_points_1d) :
true;
}
// ---------------------------------------------------------------------
-#ifndef dealii_matrix_free_fe_evaluation_base_data_h
-#define dealii_matrix_free_fe_evaluation_base_data_h
+#ifndef dealii_matrix_free_fe_evaluation_data_h
+#define dealii_matrix_free_fe_evaluation_data_h
#include <deal.II/base/config.h>
{
namespace MatrixFreeFunctions
{
- template <int, typename, typename>
+ template <int, typename>
class MappingDataOnTheFly;
}
} // namespace internal
* mapping-related information independent of the degrees of freedom and
* finite element in use. This class provides access functionality for user
* code. The main usage is through the class FEEvaluation. However, there is
- * functionality to construct an object of type FEEvaluationBaseData given
+ * functionality to construct an object of type FEEvaluationData given
* suitable data pointers to internal data, which allows usage in some
* scenarios where no full MatrixFree object is available.
*
*
* @ingroup matrixfree
*/
-template <int dim, typename Number, bool is_face, typename VectorizedArrayType>
-class FEEvaluationBaseData
+template <int dim, typename Number, bool is_face>
+class FEEvaluationData
{
- static_assert(
- std::is_same<Number, typename VectorizedArrayType::value_type>::value,
- "Type of Number and of VectorizedArrayType do not match.");
-
- using ShapeInfoType =
- internal::MatrixFreeFunctions::ShapeInfo<VectorizedArrayType>;
- using MappingInfoStorageType =
- internal::MatrixFreeFunctions::MappingInfoStorage<(is_face ? dim - 1 : dim),
- dim,
- Number,
- VectorizedArrayType>;
+ using ShapeInfoType = internal::MatrixFreeFunctions::ShapeInfo<Number>;
+ using MappingInfoStorageType = internal::MatrixFreeFunctions::
+ MappingInfoStorage<(is_face ? dim - 1 : dim), dim, Number>;
using DoFInfo = internal::MatrixFreeFunctions::DoFInfo;
public:
static constexpr unsigned int dimension = dim;
- using NumberType = VectorizedArrayType;
+ using NumberType = Number;
+
+ using ScalarNumber =
+ typename internal::VectorizedArrayTrait<Number>::value_type;
+
+ static constexpr unsigned int n_lanes = sizeof(Number) / sizeof(ScalarNumber);
/**
* Constructor, taking data stored in MatrixFree. If applied to problems
* with more than one quadrature formula selected during construction of
* `matrix_free`, `quad_no` allows to select the appropriate formula.
*/
- FEEvaluationBaseData(const std::tuple<const ShapeInfoType *,
- const DoFInfo *,
- const MappingInfoStorageType *,
- unsigned int,
- unsigned int> &info,
- const bool is_interior_face = true,
- const unsigned int quad_no = 0,
- const unsigned int face_type = 0,
- const unsigned int first_selected_component = 0);
+ FEEvaluationData(const std::tuple<const ShapeInfoType *,
+ const DoFInfo *,
+ const MappingInfoStorageType *,
+ unsigned int,
+ unsigned int> &info,
+ const bool is_interior_face = true,
+ const unsigned int quad_no = 0,
+ const unsigned int face_type = 0,
+ const unsigned int first_selected_component = 0);
/**
* Copy constructor.
*/
- FEEvaluationBaseData(const FEEvaluationBaseData &other) = default;
+ FEEvaluationData(const FEEvaluationData &other) = default;
/**
* Copy assignment operator.
*/
- FEEvaluationBaseData &
- operator=(const FEEvaluationBaseData &other);
+ FEEvaluationData &
+ operator=(const FEEvaluationData &other);
/**
* Sets the pointers for values, gradients, hessians to the central
* components as provided by one of the derived classes.
*/
void
- set_data_pointers(AlignedVector<VectorizedArrayType> *scratch_data,
- const unsigned int n_components);
+ set_data_pointers(AlignedVector<Number> *scratch_data,
+ const unsigned int n_components);
/**
* Initialize the indices related to the given face description. Used during
* the reinit() call of the FEFaceEvaluation class.
*/
void
- reinit_face(const internal::MatrixFreeFunctions::FaceToCellTopology<
- VectorizedArrayType::size()> &face);
+ reinit_face(
+ const internal::MatrixFreeFunctions::FaceToCellTopology<n_lanes> &face);
/**
* @name 1: Access to geometry data at quadrature points
* do not assume it to be stable over those calls. The maximum size you can
* write into is 3*dofs_per_cell+2*n_q_points.
*/
- ArrayView<VectorizedArrayType>
+ ArrayView<Number>
get_scratch_data() const;
/**
* Return the determinant of the Jacobian from the unit to the real cell
* times the quadrature weight.
*/
- VectorizedArrayType
+ Number
JxW(const unsigned int q_point) const;
/**
* gradients to gradients on the real cell by a multiplication $J^{-\mathrm
* T} \hat{\nabla} u_h$.
*/
- Tensor<2, dim, VectorizedArrayType>
+ Tensor<2, dim, Number>
inverse_jacobian(const unsigned int q_point) const;
/**
*
* @note Only implemented in case `is_face == true`.
*/
- Tensor<1, dim, VectorizedArrayType>
+ Tensor<1, dim, Number>
get_normal_vector(const unsigned int q_point) const;
//@}
* used in this class. In general, it is safer to use the get_dof_value()
* function instead.
*/
- const VectorizedArrayType *
+ const Number *
begin_dof_values() const;
/**
* structures used in this class. In general, it is safer to use the
* get_dof_value() function instead.
*/
- VectorizedArrayType *
+ Number *
begin_dof_values();
/**
* applied manually. In general, it is safer to use the get_value() function
* instead, which does all the transformation internally.
*/
- const VectorizedArrayType *
+ const Number *
begin_values() const;
/**
* applied manually. In general, it is safer to use the get_value() function
* instead, which does all the transformation internally.
*/
- VectorizedArrayType *
+ Number *
begin_values();
/**
* manually. In general, it is safer to use the get_gradient() function
* instead, which does all the transformation internally.
*/
- const VectorizedArrayType *
+ const Number *
begin_gradients() const;
/**
* manually. In general, it is safer to use the get_gradient() function
* instead, which does all the transformation internally.
*/
- VectorizedArrayType *
+ Number *
begin_gradients();
/**
* general, it is safer to use the get_laplacian() or get_hessian()
* functions instead, which does all the transformation internally.
*/
- const VectorizedArrayType *
+ const Number *
begin_hessians() const;
/**
* general, it is safer to use the get_laplacian() or get_hessian()
* functions instead, which does all the transformation internally.
*/
- VectorizedArrayType *
+ Number *
begin_hessians();
//@}
* Return the id of the cells this FEEvaluation or FEFaceEvaluation is
* associated with.
*/
- const std::array<unsigned int, VectorizedArrayType::size()> &
+ const std::array<unsigned int, n_lanes> &
get_cell_ids() const;
/**
* Return the id of the cells/faces this FEEvaluation/FEFaceEvaluation is
* associated with.
*/
- const std::array<unsigned int, VectorizedArrayType::size()> &
+ const std::array<unsigned int, n_lanes> &
get_cell_or_face_ids() const;
/**
* is not stable between releases of deal.II, and is hence mostly for
* internal use.
*/
- const std::array<std::uint8_t, VectorizedArrayType::size()> &
+ const std::array<std::uint8_t, n_lanes> &
get_all_face_numbers() const;
/**
* @note Only available for `dof_access_index == dof_access_cell` and
* `is_interior_face == false`.
*/
- const std::array<std::uint8_t, VectorizedArrayType::size()> &
+ const std::array<std::uint8_t, n_lanes> &
get_all_face_orientations() const;
//@}
* Constructor that comes with reduced functionality and works similarly as
* FEValues.
*/
- FEEvaluationBaseData(
+ FEEvaluationData(
const std::shared_ptr<
- internal::MatrixFreeFunctions::
- MappingDataOnTheFly<dim, Number, VectorizedArrayType>> &mapping_data,
- const unsigned int n_fe_components,
+ internal::MatrixFreeFunctions::MappingDataOnTheFly<dim, Number>>
+ & mapping_data,
+ const unsigned int n_fe_components,
const unsigned int first_selected_component);
/**
* A pointer to the Jacobian information of the present cell. Only set to a
* useful value if on a non-Cartesian cell.
*/
- const Tensor<2, dim, VectorizedArrayType> *jacobian;
+ const Tensor<2, dim, Number> *jacobian;
/**
* A pointer to the Jacobian determinant of the present cell. If on a
* Jacobian determinant, otherwise the Jacobian determinant times the
* quadrature weight.
*/
- const VectorizedArrayType *J_value;
+ const Number *J_value;
/**
* A pointer to the normal vectors at faces.
*/
- const Tensor<1, dim, VectorizedArrayType> *normal_vectors;
+ const Tensor<1, dim, Number> *normal_vectors;
/**
* A pointer to the normal vectors times the jacobian at faces.
*/
- const Tensor<1, dim, VectorizedArrayType> *normal_x_jacobian;
+ const Tensor<1, dim, Number> *normal_x_jacobian;
/**
* A pointer to the quadrature weights of the underlying quadrature formula.
*/
- const Number *quadrature_weights;
+ const ScalarNumber *quadrature_weights;
/**
* This is the user-visible part of FEEvaluationBase::scratch_data_array,
* during the allocation of the internal data structures in
* FEEvaluationBase.
*/
- mutable ArrayView<VectorizedArrayType> scratch_data;
+ mutable ArrayView<Number> scratch_data;
/**
* This field stores the values for local degrees of freedom (e.g. after
* @p scratch_data_array. Due to its access as a thread local memory, the
* memory can get reused between different calls.
*/
- VectorizedArrayType *values_dofs;
+ Number *values_dofs;
/**
* This field stores the values of the finite element function on quadrature
* @p scratch_data_array. Due to its access as a thread local memory, the
* memory can get reused between different calls.
*/
- VectorizedArrayType *values_quad;
+ Number *values_quad;
/**
* This field stores the gradients of the finite element function on
* @p scratch_data_array. Due to its access as a thread local memory, the
* memory can get reused between different calls.
*/
- VectorizedArrayType *gradients_quad;
+ Number *gradients_quad;
/**
* This field stores the gradients of the finite element function on
* @p scratch_data_array. Due to its access as a thread local memory, the
* memory can get reused between different calls.
*/
- VectorizedArrayType *gradients_from_hessians_quad;
+ Number *gradients_from_hessians_quad;
/**
* This field stores the Hessians of the finite element function on
* @p scratch_data_array. Due to its access as a thread local memory, the
* memory can get reused between different calls.
*/
- VectorizedArrayType *hessians_quad;
+ Number *hessians_quad;
/**
* Debug information to track whether dof values have been initialized
* Stores the (non-vectorized) id of the cells or faces this object is
* initialized to. Relevant for ECL.
*/
- std::array<unsigned int, VectorizedArrayType::size()> cell_ids;
+ std::array<unsigned int, n_lanes> cell_ids;
/**
* Stores the (non-vectorized) id of the cells or faces this object is
* initialized to. Relevant for ECL.
*/
- std::array<unsigned int, VectorizedArrayType::size()> cell_or_face_ids;
+ std::array<unsigned int, n_lanes> cell_or_face_ids;
/**
* Stores the (non-vectorized) number of faces within cells in case of ECL
* @note Only available for `dof_access_index == dof_access_cell` and
* `is_interior_face == false`.
*/
- std::array<std::uint8_t, VectorizedArrayType::size()> all_face_numbers;
+ std::array<std::uint8_t, n_lanes> all_face_numbers;
/**
* Store the orientation of the neighbor's faces with respect to the current
* @note Only available for `dof_access_index == dof_access_cell` and
* `is_interior_face == false`.
*/
- std::array<std::uint8_t, VectorizedArrayType::size()> all_face_orientations;
+ std::array<std::uint8_t, n_lanes> all_face_orientations;
/**
* Geometry data that can be generated FEValues on the fly with the
* respective constructor, as an alternative to the entry point with
* MatrixFree.
*/
- std::shared_ptr<internal::MatrixFreeFunctions::
- MappingDataOnTheFly<dim, Number, VectorizedArrayType>>
+ std::shared_ptr<
+ internal::MatrixFreeFunctions::MappingDataOnTheFly<dim, Number>>
mapped_geometry;
// Make FEEvaluation and FEEvaluationBase objects friends for access to
#ifndef DOXYGEN
-template <int dim, typename Number, bool is_face, typename VectorizedArrayType>
-inline FEEvaluationBaseData<dim, Number, is_face, VectorizedArrayType>::
- FEEvaluationBaseData(const std::tuple<const ShapeInfoType *,
- const DoFInfo *,
- const MappingInfoStorageType *,
- unsigned int,
- unsigned int> &shape_dof_info,
- const bool is_interior_face,
- const unsigned int quad_no,
- const unsigned int face_type,
- const unsigned int first_selected_component)
+template <int dim, typename Number, bool is_face>
+inline FEEvaluationData<dim, Number, is_face>::FEEvaluationData(
+ const std::tuple<const ShapeInfoType *,
+ const DoFInfo *,
+ const MappingInfoStorageType *,
+ unsigned int,
+ unsigned int> &shape_dof_info,
+ const bool is_interior_face,
+ const unsigned int quad_no,
+ const unsigned int face_type,
+ const unsigned int first_selected_component)
: data(std::get<0>(shape_dof_info))
, dof_info(std::get<1>(shape_dof_info))
, mapping_data(std::get<2>(shape_dof_info))
-template <int dim, typename Number, bool is_face, typename VectorizedArrayType>
-inline FEEvaluationBaseData<dim, Number, is_face, VectorizedArrayType>::
- FEEvaluationBaseData(
- const std::shared_ptr<
- internal::MatrixFreeFunctions::
- MappingDataOnTheFly<dim, Number, VectorizedArrayType>> &mapped_geometry,
- const unsigned int n_fe_components,
- const unsigned int first_selected_component)
+template <int dim, typename Number, bool is_face>
+inline FEEvaluationData<dim, Number, is_face>::FEEvaluationData(
+ const std::shared_ptr<
+ internal::MatrixFreeFunctions::MappingDataOnTheFly<dim, Number>>
+ & mapped_geometry,
+ const unsigned int n_fe_components,
+ const unsigned int first_selected_component)
: data(nullptr)
, dof_info(nullptr)
, mapping_data(nullptr)
-template <int dim, typename Number, bool is_face, typename VectorizedArrayType>
-inline FEEvaluationBaseData<dim, Number, is_face, VectorizedArrayType> &
-FEEvaluationBaseData<dim, Number, is_face, VectorizedArrayType>::operator=(
- const FEEvaluationBaseData &other)
+template <int dim, typename Number, bool is_face>
+inline FEEvaluationData<dim, Number, is_face> &
+FEEvaluationData<dim, Number, is_face>::operator=(const FEEvaluationData &other)
{
AssertDimension(quad_no, other.quad_no);
AssertDimension(n_fe_components, other.n_fe_components);
-template <int dim, typename Number, bool is_face, typename VectorizedArrayType>
+template <int dim, typename Number, bool is_face>
inline void
-FEEvaluationBaseData<dim, Number, is_face, VectorizedArrayType>::
- set_data_pointers(AlignedVector<VectorizedArrayType> *scratch_data_array,
- const unsigned int n_components)
+FEEvaluationData<dim, Number, is_face>::set_data_pointers(
+ AlignedVector<Number> *scratch_data_array,
+ const unsigned int n_components)
{
Assert(scratch_data_array != nullptr, ExcInternalError());
-template <int dim, typename Number, bool is_face, typename VectorizedArrayType>
+template <int dim, typename Number, bool is_face>
inline void
-FEEvaluationBaseData<dim, Number, is_face, VectorizedArrayType>::reinit_face(
- const internal::MatrixFreeFunctions::FaceToCellTopology<
- VectorizedArrayType::size()> &face)
+FEEvaluationData<dim, Number, is_face>::reinit_face(
+ const internal::MatrixFreeFunctions::FaceToCellTopology<n_lanes> &face)
{
Assert(is_face == true,
ExcMessage("Faces can only be set if the is_face template parameter "
-template <int dim, typename Number, bool is_face, typename VectorizedArrayType>
-inline DEAL_II_ALWAYS_INLINE Tensor<1, dim, VectorizedArrayType>
-FEEvaluationBaseData<dim, Number, is_face, VectorizedArrayType>::
- get_normal_vector(const unsigned int q_point) const
+template <int dim, typename Number, bool is_face>
+inline DEAL_II_ALWAYS_INLINE Tensor<1, dim, Number>
+FEEvaluationData<dim, Number, is_face>::get_normal_vector(
+ const unsigned int q_point) const
{
AssertIndexRange(q_point, n_quadrature_points);
Assert(normal_vectors != nullptr,
-template <int dim, typename Number, bool is_face, typename VectorizedArrayType>
-inline DEAL_II_ALWAYS_INLINE VectorizedArrayType
-FEEvaluationBaseData<dim, Number, is_face, VectorizedArrayType>::JxW(
- const unsigned int q_point) const
+template <int dim, typename Number, bool is_face>
+inline DEAL_II_ALWAYS_INLINE Number
+FEEvaluationData<dim, Number, is_face>::JxW(const unsigned int q_point) const
{
AssertIndexRange(q_point, n_quadrature_points);
Assert(J_value != nullptr,
-template <int dim, typename Number, bool is_face, typename VectorizedArrayType>
-inline DEAL_II_ALWAYS_INLINE Tensor<2, dim, VectorizedArrayType>
-FEEvaluationBaseData<dim, Number, is_face, VectorizedArrayType>::
- inverse_jacobian(const unsigned int q_point) const
+template <int dim, typename Number, bool is_face>
+inline DEAL_II_ALWAYS_INLINE Tensor<2, dim, Number>
+FEEvaluationData<dim, Number, is_face>::inverse_jacobian(
+ const unsigned int q_point) const
{
AssertIndexRange(q_point, n_quadrature_points);
Assert(jacobian != nullptr,
-template <int dim, typename Number, bool is_face, typename VectorizedArrayType>
-inline const VectorizedArrayType *
-FEEvaluationBaseData<dim, Number, is_face, VectorizedArrayType>::
- begin_dof_values() const
+template <int dim, typename Number, bool is_face>
+inline const Number *
+FEEvaluationData<dim, Number, is_face>::begin_dof_values() const
{
return values_dofs;
}
-template <int dim, typename Number, bool is_face, typename VectorizedArrayType>
-inline VectorizedArrayType *
-FEEvaluationBaseData<dim, Number, is_face, VectorizedArrayType>::
- begin_dof_values()
+template <int dim, typename Number, bool is_face>
+inline Number *
+FEEvaluationData<dim, Number, is_face>::begin_dof_values()
{
# ifdef DEBUG
dof_values_initialized = true;
-template <int dim, typename Number, bool is_face, typename VectorizedArrayType>
-inline const VectorizedArrayType *
-FEEvaluationBaseData<dim, Number, is_face, VectorizedArrayType>::begin_values()
- const
+template <int dim, typename Number, bool is_face>
+inline const Number *
+FEEvaluationData<dim, Number, is_face>::begin_values() const
{
# ifdef DEBUG
Assert(values_quad_initialized || values_quad_submitted, ExcNotInitialized());
-template <int dim, typename Number, bool is_face, typename VectorizedArrayType>
-inline VectorizedArrayType *
-FEEvaluationBaseData<dim, Number, is_face, VectorizedArrayType>::begin_values()
+template <int dim, typename Number, bool is_face>
+inline Number *
+FEEvaluationData<dim, Number, is_face>::begin_values()
{
# ifdef DEBUG
values_quad_initialized = true;
-template <int dim, typename Number, bool is_face, typename VectorizedArrayType>
-inline const VectorizedArrayType *
-FEEvaluationBaseData<dim, Number, is_face, VectorizedArrayType>::
- begin_gradients() const
+template <int dim, typename Number, bool is_face>
+inline const Number *
+FEEvaluationData<dim, Number, is_face>::begin_gradients() const
{
# ifdef DEBUG
Assert(gradients_quad_initialized || gradients_quad_submitted,
-template <int dim, typename Number, bool is_face, typename VectorizedArrayType>
-inline VectorizedArrayType *
-FEEvaluationBaseData<dim, Number, is_face, VectorizedArrayType>::
- begin_gradients()
+template <int dim, typename Number, bool is_face>
+inline Number *
+FEEvaluationData<dim, Number, is_face>::begin_gradients()
{
# ifdef DEBUG
gradients_quad_submitted = true;
-template <int dim, typename Number, bool is_face, typename VectorizedArrayType>
-inline const VectorizedArrayType *
-FEEvaluationBaseData<dim, Number, is_face, VectorizedArrayType>::
- begin_hessians() const
+template <int dim, typename Number, bool is_face>
+inline const Number *
+FEEvaluationData<dim, Number, is_face>::begin_hessians() const
{
# ifdef DEBUG
Assert(hessians_quad_initialized, ExcNotInitialized());
-template <int dim, typename Number, bool is_face, typename VectorizedArrayType>
-inline VectorizedArrayType *
-FEEvaluationBaseData<dim, Number, is_face, VectorizedArrayType>::
- begin_hessians()
+template <int dim, typename Number, bool is_face>
+inline Number *
+FEEvaluationData<dim, Number, is_face>::begin_hessians()
{
# ifdef DEBUG
hessians_quad_initialized = true;
-template <int dim, typename Number, bool is_face, typename VectorizedArrayType>
+template <int dim, typename Number, bool is_face>
inline unsigned int
-FEEvaluationBaseData<dim, Number, is_face, VectorizedArrayType>::
- get_mapping_data_index_offset() const
+FEEvaluationData<dim, Number, is_face>::get_mapping_data_index_offset() const
{
Assert(mapping_data != nullptr, ExcInternalError());
-template <int dim, typename Number, bool is_face, typename VectorizedArrayType>
+template <int dim, typename Number, bool is_face>
inline internal::MatrixFreeFunctions::GeometryType
-FEEvaluationBaseData<dim, Number, is_face, VectorizedArrayType>::get_cell_type()
- const
+FEEvaluationData<dim, Number, is_face>::get_cell_type() const
{
Assert(cell != numbers::invalid_unsigned_int, ExcNotInitialized());
return cell_type;
-template <int dim, typename Number, bool is_face, typename VectorizedArrayType>
-inline const internal::MatrixFreeFunctions::ShapeInfo<VectorizedArrayType> &
-FEEvaluationBaseData<dim, Number, is_face, VectorizedArrayType>::
- get_shape_info() const
+template <int dim, typename Number, bool is_face>
+inline const internal::MatrixFreeFunctions::ShapeInfo<Number> &
+FEEvaluationData<dim, Number, is_face>::get_shape_info() const
{
Assert(data != nullptr, ExcInternalError());
return *data;
-template <int dim, typename Number, bool is_face, typename VectorizedArrayType>
+template <int dim, typename Number, bool is_face>
inline const internal::MatrixFreeFunctions::DoFInfo &
-FEEvaluationBaseData<dim, Number, is_face, VectorizedArrayType>::get_dof_info()
- const
+FEEvaluationData<dim, Number, is_face>::get_dof_info() const
{
Assert(dof_info != nullptr,
ExcMessage(
-template <int dim, typename Number, bool is_face, typename VectorizedArrayType>
+template <int dim, typename Number, bool is_face>
inline const std::vector<unsigned int> &
-FEEvaluationBaseData<dim, Number, is_face, VectorizedArrayType>::
- get_internal_dof_numbering() const
+FEEvaluationData<dim, Number, is_face>::get_internal_dof_numbering() const
{
return data->lexicographic_numbering;
}
-template <int dim, typename Number, bool is_face, typename VectorizedArrayType>
+template <int dim, typename Number, bool is_face>
inline unsigned int
-FEEvaluationBaseData<dim, Number, is_face, VectorizedArrayType>::
- get_quadrature_index() const
+FEEvaluationData<dim, Number, is_face>::get_quadrature_index() const
{
return quad_no;
}
-template <int dim, typename Number, bool is_face, typename VectorizedArrayType>
+template <int dim, typename Number, bool is_face>
inline unsigned int
-FEEvaluationBaseData<dim, Number, is_face, VectorizedArrayType>::
- get_current_cell_index() const
+FEEvaluationData<dim, Number, is_face>::get_current_cell_index() const
{
if (is_face && dof_access_index ==
internal::MatrixFreeFunctions::DoFInfo::dof_access_cell)
-template <int dim, typename Number, bool is_face, typename VectorizedArrayType>
+template <int dim, typename Number, bool is_face>
inline unsigned int
-FEEvaluationBaseData<dim, Number, is_face, VectorizedArrayType>::
- get_active_fe_index() const
+FEEvaluationData<dim, Number, is_face>::get_active_fe_index() const
{
return active_fe_index;
}
-template <int dim, typename Number, bool is_face, typename VectorizedArrayType>
+template <int dim, typename Number, bool is_face>
inline unsigned int
-FEEvaluationBaseData<dim, Number, is_face, VectorizedArrayType>::
- get_active_quadrature_index() const
+FEEvaluationData<dim, Number, is_face>::get_active_quadrature_index() const
{
return active_quad_index;
}
-template <int dim, typename Number, bool is_face, typename VectorizedArrayType>
+template <int dim, typename Number, bool is_face>
inline unsigned int
-FEEvaluationBaseData<dim, Number, is_face, VectorizedArrayType>::
- get_first_selected_component() const
+FEEvaluationData<dim, Number, is_face>::get_first_selected_component() const
{
return first_selected_component;
}
-template <int dim, typename Number, bool is_face, typename VectorizedArrayType>
-inline ArrayView<VectorizedArrayType>
-FEEvaluationBaseData<dim, Number, is_face, VectorizedArrayType>::
- get_scratch_data() const
+template <int dim, typename Number, bool is_face>
+inline ArrayView<Number>
+FEEvaluationData<dim, Number, is_face>::get_scratch_data() const
{
return scratch_data;
}
-template <int dim, typename Number, bool is_face, typename VectorizedArrayType>
+template <int dim, typename Number, bool is_face>
inline unsigned int
-FEEvaluationBaseData<dim, Number, is_face, VectorizedArrayType>::get_face_no()
- const
+FEEvaluationData<dim, Number, is_face>::get_face_no() const
{
return face_no;
}
-template <int dim, typename Number, bool is_face, typename VectorizedArrayType>
+template <int dim, typename Number, bool is_face>
inline unsigned int
-FEEvaluationBaseData<dim, Number, is_face, VectorizedArrayType>::
- get_subface_index() const
+FEEvaluationData<dim, Number, is_face>::get_subface_index() const
{
return subface_index;
}
-template <int dim, typename Number, bool is_face, typename VectorizedArrayType>
+template <int dim, typename Number, bool is_face>
inline unsigned int
-FEEvaluationBaseData<dim, Number, is_face, VectorizedArrayType>::
- get_face_orientation() const
+FEEvaluationData<dim, Number, is_face>::get_face_orientation() const
{
return face_orientation;
}
-template <int dim, typename Number, bool is_face, typename VectorizedArrayType>
+template <int dim, typename Number, bool is_face>
inline const Table<2, unsigned int> &
-FEEvaluationBaseData<dim, Number, is_face, VectorizedArrayType>::
- get_orientation_map() const
+FEEvaluationData<dim, Number, is_face>::get_orientation_map() const
{
Assert(descriptor != nullptr, ExcNotInitialized());
return descriptor->face_orientations;
-template <int dim, typename Number, bool is_face, typename VectorizedArrayType>
+template <int dim, typename Number, bool is_face>
inline internal::MatrixFreeFunctions::DoFInfo::DoFAccessIndex
-FEEvaluationBaseData<dim, Number, is_face, VectorizedArrayType>::
- get_dof_access_index() const
+FEEvaluationData<dim, Number, is_face>::get_dof_access_index() const
{
return dof_access_index;
}
-template <int dim, typename Number, bool is_face, typename VectorizedArrayType>
+template <int dim, typename Number, bool is_face>
inline bool
-FEEvaluationBaseData<dim, Number, is_face, VectorizedArrayType>::
- get_is_interior_face() const
+FEEvaluationData<dim, Number, is_face>::get_is_interior_face() const
{
return is_interior_face;
}
-template <int dim, typename Number, bool is_face, typename VectorizedArrayType>
-inline const std::array<unsigned int, VectorizedArrayType::size()> &
-FEEvaluationBaseData<dim, Number, is_face, VectorizedArrayType>::get_cell_ids()
- const
+template <int dim, typename Number, bool is_face>
+inline const std::array<unsigned int,
+ FEEvaluationData<dim, Number, is_face>::n_lanes> &
+FEEvaluationData<dim, Number, is_face>::get_cell_ids() const
{
Assert(cell != numbers::invalid_unsigned_int, ExcNotInitialized());
return cell_ids;
-template <int dim, typename Number, bool is_face, typename VectorizedArrayType>
-inline const std::array<unsigned int, VectorizedArrayType::size()> &
-FEEvaluationBaseData<dim, Number, is_face, VectorizedArrayType>::
- get_cell_or_face_ids() const
+template <int dim, typename Number, bool is_face>
+inline const std::array<unsigned int,
+ FEEvaluationData<dim, Number, is_face>::n_lanes> &
+FEEvaluationData<dim, Number, is_face>::get_cell_or_face_ids() const
{
Assert(cell != numbers::invalid_unsigned_int, ExcNotInitialized());
if (!is_face || dof_access_index ==
-template <int dim, typename Number, bool is_face, typename VectorizedArrayType>
-inline const std::array<std::uint8_t, VectorizedArrayType::size()> &
-FEEvaluationBaseData<dim, Number, is_face, VectorizedArrayType>::
- get_all_face_numbers() const
+template <int dim, typename Number, bool is_face>
+inline const std::array<std::uint8_t,
+ FEEvaluationData<dim, Number, is_face>::n_lanes> &
+FEEvaluationData<dim, Number, is_face>::get_all_face_numbers() const
{
Assert(cell != numbers::invalid_unsigned_int, ExcNotInitialized());
Assert(is_face &&
-template <int dim, typename Number, bool is_face, typename VectorizedArrayType>
-inline const std::array<std::uint8_t, VectorizedArrayType::size()> &
-FEEvaluationBaseData<dim, Number, is_face, VectorizedArrayType>::
- get_all_face_orientations() const
+template <int dim, typename Number, bool is_face>
+inline const std::array<std::uint8_t,
+ FEEvaluationData<dim, Number, is_face>::n_lanes> &
+FEEvaluationData<dim, Number, is_face>::get_all_face_orientations() const
{
Assert(cell != numbers::invalid_unsigned_int, ExcNotInitialized());
Assert(is_face &&
* deal.II information in a form that FEEvaluation and friends can use for
* vectorized access. Since no vectorization over cells is available with
* the DoFHandler/Triangulation cell iterators, the interface to
- * FEEvaluation's vectorization model is to use @p
- * VectorizedArray::n_array_element copies of the same element. This
- * interface is thus primarily useful for evaluating several operators on
- * the same cell, e.g., when assembling cell matrices.
+ * FEEvaluation's vectorization model is to use VectorizedArray::size()
+ * copies of the same element. This interface is thus primarily useful for
+ * evaluating several operators on the same cell, e.g., when assembling
+ * cell matrices.
*
* As opposed to the Mapping classes in deal.II, this class does not
* actually provide a boundary description that can be used to evaluate
* given deal.II mapping (as passed to the constructor of this class) in a
* form accessible to FEEvaluation.
*/
- template <int dim, typename Number, typename VectorizedArrayType>
+ template <int dim, typename Number>
class MappingDataOnTheFly
{
- static_assert(
- std::is_same<Number, typename VectorizedArrayType::value_type>::value,
- "Type of Number and of VectorizedArrayType do not match.");
-
public:
/**
* Constructor, similar to FEValues. Since this class only evaluates the
* MappingInfo. This ensures compatibility with the precomputed data
* fields in the MappingInfo class.
*/
- const MappingInfoStorage<dim, dim, Number, VectorizedArrayType> &
+ const MappingInfoStorage<dim, dim, Number> &
get_data_storage() const;
/**
* The storage part created for a single cell and held in analogy to
* MappingInfo.
*/
- MappingInfoStorage<dim, dim, Number, VectorizedArrayType>
- mapping_info_storage;
+ MappingInfoStorage<dim, dim, Number> mapping_info_storage;
};
/*-------------------------- Inline functions ---------------------------*/
- template <int dim, typename Number, typename VectorizedArrayType>
- inline MappingDataOnTheFly<dim, Number, VectorizedArrayType>::
- MappingDataOnTheFly(const Mapping<dim> & mapping,
- const Quadrature<1> &quadrature,
- const UpdateFlags update_flags)
- : fe_values(
- mapping,
- fe_dummy,
- Quadrature<dim>(quadrature),
- MappingInfo<dim, Number, VectorizedArrayType>::compute_update_flags(
- update_flags))
+ template <int dim, typename Number>
+ inline MappingDataOnTheFly<dim, Number>::MappingDataOnTheFly(
+ const Mapping<dim> & mapping,
+ const Quadrature<1> &quadrature,
+ const UpdateFlags update_flags)
+ : fe_values(mapping,
+ fe_dummy,
+ Quadrature<dim>(quadrature),
+ MappingInfoStorage<dim, dim, Number>::compute_update_flags(
+ update_flags))
, quadrature_1d(quadrature)
{
mapping_info_storage.descriptor.resize(1);
- template <int dim, typename Number, typename VectorizedArrayType>
- inline MappingDataOnTheFly<dim, Number, VectorizedArrayType>::
- MappingDataOnTheFly(const Quadrature<1> &quadrature,
- const UpdateFlags update_flags)
+ template <int dim, typename Number>
+ inline MappingDataOnTheFly<dim, Number>::MappingDataOnTheFly(
+ const Quadrature<1> &quadrature,
+ const UpdateFlags update_flags)
: MappingDataOnTheFly(::dealii::StaticMappingQ1<dim, dim>::mapping,
quadrature,
update_flags)
- template <int dim, typename Number, typename VectorizedArrayType>
+ template <int dim, typename Number>
inline void
- MappingDataOnTheFly<dim, Number, VectorizedArrayType>::reinit(
+ MappingDataOnTheFly<dim, Number>::reinit(
typename dealii::Triangulation<dim>::cell_iterator cell)
{
if (present_cell == cell)
- template <int dim, typename Number, typename VectorizedArrayType>
+ template <int dim, typename Number>
inline bool
- MappingDataOnTheFly<dim, Number, VectorizedArrayType>::is_initialized()
- const
+ MappingDataOnTheFly<dim, Number>::is_initialized() const
{
return present_cell !=
typename dealii::Triangulation<dim>::cell_iterator();
- template <int dim, typename Number, typename VectorizedArrayType>
+ template <int dim, typename Number>
inline typename dealii::Triangulation<dim>::cell_iterator
- MappingDataOnTheFly<dim, Number, VectorizedArrayType>::get_cell() const
+ MappingDataOnTheFly<dim, Number>::get_cell() const
{
return fe_values.get_cell();
}
- template <int dim, typename Number, typename VectorizedArrayType>
+ template <int dim, typename Number>
inline const dealii::FEValues<dim> &
- MappingDataOnTheFly<dim, Number, VectorizedArrayType>::get_fe_values() const
+ MappingDataOnTheFly<dim, Number>::get_fe_values() const
{
return fe_values;
}
- template <int dim, typename Number, typename VectorizedArrayType>
- inline const MappingInfoStorage<dim, dim, Number, VectorizedArrayType> &
- MappingDataOnTheFly<dim, Number, VectorizedArrayType>::get_data_storage()
- const
+ template <int dim, typename Number>
+ inline const MappingInfoStorage<dim, dim, Number> &
+ MappingDataOnTheFly<dim, Number>::get_data_storage() const
{
return mapping_info_storage;
}
- template <int dim, typename Number, typename VectorizedArrayType>
+ template <int dim, typename Number>
inline const Quadrature<1> &
- MappingDataOnTheFly<dim, Number, VectorizedArrayType>::get_quadrature()
- const
+ MappingDataOnTheFly<dim, Number>::get_quadrature() const
{
return quadrature_1d;
}
/**
* The data cache for the cells.
*/
- std::vector<MappingInfoStorage<dim, dim, Number, VectorizedArrayType>>
- cell_data;
+ std::vector<MappingInfoStorage<dim, dim, VectorizedArrayType>> cell_data;
/**
* The data cache for the faces.
*/
- std::vector<MappingInfoStorage<dim - 1, dim, Number, VectorizedArrayType>>
+ std::vector<MappingInfoStorage<dim - 1, dim, VectorizedArrayType>>
face_data;
/**
* The data cache for the face-associated-with-cell topology, following
* the @p cell_type variable for the cell types.
*/
- std::vector<MappingInfoStorage<dim - 1, dim, Number, VectorizedArrayType>>
+ std::vector<MappingInfoStorage<dim - 1, dim, VectorizedArrayType>>
face_data_by_cells;
/**
const dealii::Triangulation<dim> & tria,
const std::vector<std::pair<unsigned int, unsigned int>> &cells,
const dealii::hp::MappingCollection<dim> & mapping);
-
- /**
- * Helper function to determine which update flags must be set in the
- * internal functions to initialize all data as requested by the user.
- */
- static UpdateFlags
- compute_update_flags(
- const UpdateFlags update_flags,
- const std::vector<dealii::hp::QCollection<dim>> &quad =
- std::vector<dealii::hp::QCollection<dim>>());
};
template <int dim, typename Number, typename VectorizedArrayType>
struct MappingInfoCellsOrFaces<dim, Number, false, VectorizedArrayType>
{
- static const MappingInfoStorage<dim, dim, Number, VectorizedArrayType> &
+ static const MappingInfoStorage<dim, dim, VectorizedArrayType> &
get(const MappingInfo<dim, Number, VectorizedArrayType> &mapping_info,
const unsigned int quad_no)
{
template <int dim, typename Number, typename VectorizedArrayType>
struct MappingInfoCellsOrFaces<dim, Number, true, VectorizedArrayType>
{
- static const MappingInfoStorage<dim - 1, dim, Number, VectorizedArrayType>
- &
- get(const MappingInfo<dim, Number, VectorizedArrayType> &mapping_info,
- const unsigned int quad_no)
+ static const MappingInfoStorage<dim - 1, dim, VectorizedArrayType> &
+ get(const MappingInfo<dim, Number, VectorizedArrayType> &mapping_info,
+ const unsigned int quad_no)
{
AssertIndexRange(quad_no, mapping_info.face_data.size());
return mapping_info.face_data[quad_no];
#include <deal.II/fe/mapping_q.h>
#include <deal.II/matrix_free/evaluation_template_factory.h>
-#include <deal.II/matrix_free/fe_evaluation_base_data.h>
+#include <deal.II/matrix_free/fe_evaluation_data.h>
#include <deal.II/matrix_free/mapping_info.h>
#include <deal.II/matrix_free/mapping_info_storage.templates.h>
#include <deal.II/matrix_free/util.h>
- template <int dim, typename Number, typename VectorizedArrayType>
- UpdateFlags
- MappingInfo<dim, Number, VectorizedArrayType>::compute_update_flags(
- const UpdateFlags update_flags,
- const std::vector<dealii::hp::QCollection<dim>> &quad)
- {
- // this class is build around the evaluation of jacobians, so compute
- // them in any case. The Jacobians will be inverted manually. Since we
- // always do support integration, we also include the JxW values
- UpdateFlags new_flags = update_jacobians | update_JxW_values;
-
- // for Hessian information, need inverse Jacobians and the derivative of
- // Jacobians (these two together will give use the gradients of the
- // inverse Jacobians, which is what we need)
- if (update_flags & update_hessians ||
- update_flags & update_jacobian_grads)
- new_flags |= update_jacobian_grads;
-
- if (update_flags & update_quadrature_points)
- new_flags |= update_quadrature_points;
-
- // there is one more thing: if we have a quadrature formula with only
- // one quadrature point on the first component, but more points on later
- // components, we need to have Jacobian gradients anyway in order to
- // determine whether the Jacobian is constant throughout a cell
- if (quad.empty() == false)
- {
- bool formula_with_one_point = false;
- for (unsigned int i = 0; i < quad[0].size(); ++i)
- if (quad[0][i].size() == 1)
- {
- formula_with_one_point = true;
- break;
- }
- if (formula_with_one_point == true)
- for (unsigned int comp = 1; comp < quad.size(); ++comp)
- for (unsigned int i = 0; i < quad[comp].size(); ++i)
- if (quad[comp][i].size() > 1)
- {
- new_flags |= update_jacobian_grads;
- }
- }
- return new_flags;
- }
-
-
-
template <int dim, typename Number, typename VectorizedArrayType>
void
MappingInfo<dim, Number, VectorizedArrayType>::initialize(
// dummy FE that is used to set up an FEValues object. Do not need the
// actual finite element because we will only evaluate quantities for
// the mapping that are independent of the FE
- this->update_flags_cells = compute_update_flags(update_flags_cells, quad);
+ this->update_flags_cells =
+ MappingInfoStorage<dim, dim, VectorizedArrayType>::compute_update_flags(
+ update_flags_cells, quad);
this->update_flags_boundary_faces =
((update_flags_inner_faces | update_flags_boundary_faces) &
const std::vector<unsigned int> & active_fe_index,
const dealii::hp::MappingCollection<dim> & mapping,
MappingInfo<dim, Number, VectorizedArrayType> &mapping_info,
- std::pair<std::vector<
- MappingInfoStorage<dim, dim, Number, VectorizedArrayType>>,
- CompressedCellData<dim, Number, VectorizedArrayType>> &data)
+ std::pair<
+ std::vector<MappingInfoStorage<dim, dim, VectorizedArrayType>>,
+ CompressedCellData<dim, Number, VectorizedArrayType>> &data)
{
FE_Nothing<dim> dummy_fe;
typename Number,
typename VectorizedArrayType>
void
- copy_data(const unsigned int first_cell,
- const std::array<std::size_t, 2> &data_shift,
- const std::vector<unsigned int> & indices_compressed,
- const std::vector<GeometryType> & cell_type,
- MappingInfoStorage<structdim, dim, Number, VectorizedArrayType>
- &data_cells_local,
- MappingInfoStorage<structdim, dim, Number, VectorizedArrayType>
- &data_cells)
+ copy_data(
+ const unsigned int first_cell,
+ const std::array<std::size_t, 2> &data_shift,
+ const std::vector<unsigned int> & indices_compressed,
+ const std::vector<GeometryType> & cell_type,
+ MappingInfoStorage<structdim, dim, VectorizedArrayType>
+ &data_cells_local,
+ MappingInfoStorage<structdim, dim, VectorizedArrayType> &data_cells)
{
// Copy the index offsets and shift by the appropriate value
for (unsigned int lcell = 0;
const UpdateFlags update_flags_cells,
const AlignedVector<double> & plain_quadrature_points,
const ShapeInfo<VectorizedDouble> &shape_info,
- MappingInfoStorage<dim, dim, Number, VectorizedArrayType> &my_data)
+ MappingInfoStorage<dim, dim, VectorizedArrayType> &my_data)
{
constexpr unsigned int n_lanes = VectorizedArrayType::size();
constexpr unsigned int n_lanes_d = VectorizedDouble::size();
shape_info.dofs_per_component_on_cell;
constexpr unsigned int hess_dim = dim * (dim + 1) / 2;
- MappingInfoStorage<dim, dim, double, VectorizedDouble> temp_data;
+ MappingInfoStorage<dim, dim, VectorizedDouble> temp_data;
temp_data.copy_descriptor(my_data);
- FEEvaluationBaseData<dim, double, false, VectorizedDouble> eval(
+ FEEvaluationData<dim, VectorizedDouble, false> eval(
{&shape_info, nullptr, &temp_data, 0, 0});
AlignedVector<VectorizedDouble> evaluation_data;
start_indices,
eval.begin_dof_values());
- FEEvaluationFactory<dim, double, VectorizedDouble>::evaluate(
+ FEEvaluationFactory<dim, VectorizedDouble>::evaluate(
dim,
EvaluationFlags::values | EvaluationFlags::gradients |
(update_flags_cells & update_jacobian_grads ?
MultithreadInfo::n_threads());
std::vector<std::pair<
- std::vector<MappingInfoStorage<dim, dim, Number, VectorizedArrayType>>,
+ std::vector<MappingInfoStorage<dim, dim, VectorizedArrayType>>,
ExtractCellHelper::
CompressedCellData<dim, Number, VectorizedArrayType>>>
data_cells_local;
while (cell_range.first < n_cell_batches)
{
data_cells_local.push_back(std::make_pair(
- std::vector<
- MappingInfoStorage<dim, dim, Number, VectorizedArrayType>>(
+ std::vector<MappingInfoStorage<dim, dim, VectorizedArrayType>>(
cell_data.size()),
ExtractCellHelper::
CompressedCellData<dim, Number, VectorizedArrayType>(
const dealii::hp::MappingCollection<dim> & mapping_in,
MappingInfo<dim, Number, VectorizedArrayType> &mapping_info,
std::pair<
- std::vector<
- MappingInfoStorage<dim - 1, dim, Number, VectorizedArrayType>>,
+ std::vector<MappingInfoStorage<dim - 1, dim, VectorizedArrayType>>,
CompressedFaceData<dim, Number, VectorizedArrayType>> &data)
{
std::vector<std::vector<std::shared_ptr<FE_Nothing<dim>>>> dummy_fe(
const unsigned int last_face,
const std::vector<GeometryType> &face_type,
const std::vector<FaceToCellTopology<VectorizedArrayType::size()>>
- &faces,
- MappingInfoStorage<dim - 1, dim, Number, VectorizedArrayType>
- &data_faces)
+ & faces,
+ MappingInfoStorage<dim - 1, dim, VectorizedArrayType> &data_faces)
{
for (unsigned int face = first_face; face < last_face; ++face)
{
const UpdateFlags update_flags_faces,
const AlignedVector<double> & plain_quadrature_points,
const ShapeInfo<VectorizedDouble> &shape_info,
- MappingInfoStorage<dim - 1, dim, Number, VectorizedArrayType> &my_data)
+ MappingInfoStorage<dim - 1, dim, VectorizedArrayType> &my_data)
{
constexpr unsigned int n_lanes = VectorizedArrayType::size();
constexpr unsigned int n_lanes_d = VectorizedDouble::size();
shape_info.dofs_per_component_on_cell;
constexpr unsigned int hess_dim = dim * (dim + 1) / 2;
- MappingInfoStorage<dim - 1, dim, double, VectorizedDouble> temp_data;
+ MappingInfoStorage<dim - 1, dim, VectorizedDouble> temp_data;
temp_data.copy_descriptor(my_data);
- FEEvaluationBaseData<dim, double, true, VectorizedDouble> eval_int(
+ FEEvaluationData<dim, VectorizedDouble, true> eval_int(
{&shape_info, nullptr, &temp_data, 0, 0}, true);
- FEEvaluationBaseData<dim, double, true, VectorizedDouble> eval_ext(
+ FEEvaluationData<dim, VectorizedDouble, true> eval_ext(
{&shape_info, nullptr, &temp_data, 0, 0}, false);
AlignedVector<VectorizedDouble> evaluation_data, evaluation_data_ext;
// now let the matrix-free evaluators provide us with the
// data on faces
- FEFaceEvaluationFactory<dim, double, VectorizedDouble>::evaluate(
+ FEFaceEvaluationFactory<dim, VectorizedDouble>::evaluate(
dim,
EvaluationFlags::values | EvaluationFlags::gradients |
(update_flags_faces & update_jacobian_grads ?
const unsigned int offset = my_data.data_index_offsets[face];
const auto compute_jacobian_grad =
- [&](unsigned int face_no,
- int is_exterior,
- unsigned int q,
- Tensor<2, dim, VectorizedDouble> inv_jac,
- FEEvaluationBaseData<dim, double, true, VectorizedDouble>
- &eval) {
+ [&](unsigned int face_no,
+ int is_exterior,
+ unsigned int q,
+ Tensor<2, dim, VectorizedDouble> inv_jac,
+ FEEvaluationData<dim, VectorizedDouble, true> &eval) {
Tensor<2, dim, VectorizedDouble> inv_transp_jac_permut;
for (unsigned int d = 0; d < dim; ++d)
for (unsigned int e = 0; e < dim; ++e)
start_indices,
eval_ext.begin_dof_values());
- FEFaceEvaluationFactory<dim, double, VectorizedDouble>::
- evaluate(dim,
- EvaluationFlags::values |
- EvaluationFlags::gradients |
- (update_flags_faces & update_jacobian_grads ?
- EvaluationFlags::hessians :
- EvaluationFlags::nothing),
- eval_ext.begin_dof_values(),
- eval_ext);
+ FEFaceEvaluationFactory<dim, VectorizedDouble>::evaluate(
+ dim,
+ EvaluationFlags::values | EvaluationFlags::gradients |
+ (update_flags_faces & update_jacobian_grads ?
+ EvaluationFlags::hessians :
+ EvaluationFlags::nothing),
+ eval_ext.begin_dof_values(),
+ eval_ext);
for (unsigned int q = 0; q < n_points_compute; ++q)
{
MultithreadInfo::n_threads());
std::vector<std::pair<
- std::vector<
- MappingInfoStorage<dim - 1, dim, Number, VectorizedArrayType>>,
+ std::vector<MappingInfoStorage<dim - 1, dim, VectorizedArrayType>>,
ExtractFaceHelper::
CompressedFaceData<dim, Number, VectorizedArrayType>>>
data_faces_local;
{
data_faces_local.push_back(std::make_pair(
std::vector<
- MappingInfoStorage<dim - 1, dim, Number, VectorizedArrayType>>(
+ MappingInfoStorage<dim - 1, dim, VectorizedArrayType>>(
face_data.size()),
ExtractFaceHelper::
CompressedFaceData<dim, Number, VectorizedArrayType>(
// points, filling up all SIMD lanes as appropriate
for (unsigned int my_q = 0; my_q < cell_data.size(); ++my_q)
{
- MappingInfoStorage<dim, dim, Number, VectorizedArrayType> &my_data =
+ MappingInfoStorage<dim, dim, VectorizedArrayType> &my_data =
cell_data[my_q];
// step 4a: set the index offsets, find out how much to allocate,
// points, filling up all SIMD lanes as appropriate
for (unsigned int my_q = 0; my_q < face_data.size(); ++my_q)
{
- MappingInfoStorage<dim - 1, dim, Number, VectorizedArrayType>
- &my_data = face_data[my_q];
+ MappingInfoStorage<dim - 1, dim, VectorizedArrayType> &my_data =
+ face_data[my_q];
// step 6a: set the index offsets, find out how much to allocate,
// and allocate the memory
*
* @ingroup matrixfree
*/
- template <int structdim,
- int spacedim,
- typename Number,
- typename VectorizedArrayType>
+ template <int structdim, int spacedim, typename Number>
struct MappingInfoStorage
{
- static_assert(
- std::is_same<Number, typename VectorizedArrayType::value_type>::value,
- "Type of Number and of VectorizedArrayType do not match.");
-
struct QuadratureDescriptor
{
+ /**
+ * In case this class is instantiated for VectorizedArray types, this
+ * indicates the underlying scalar type for data which is the same on
+ * all lanes like the quadrature weights.
+ */
+ using ScalarNumber = typename VectorizedArrayTrait<Number>::value_type;
+
/**
* Constructor. Does nothing.
*/
* Quadrature weights separated by dimension for use in specific
* situations.
*/
- std::array<AlignedVector<Number>, structdim> tensor_quadrature_weights;
+ std::array<AlignedVector<ScalarNumber>, structdim>
+ tensor_quadrature_weights;
/**
* A cached vector of quadrature weights in the given number format
* (non-vectorized, as it is cheap to broadcast the value to all lanes
* when it is used in a vectorized context).
*/
- AlignedVector<Number> quadrature_weights;
+ AlignedVector<ScalarNumber> quadrature_weights;
/**
* For quadrature on faces, the evaluation of basis functions is not
*
* Indexed by @p data_index_offsets.
*/
- AlignedVector<VectorizedArrayType> JxW_values;
+ AlignedVector<Number> JxW_values;
/**
* Stores the normal vectors.
*
* Indexed by @p data_index_offsets.
*/
- AlignedVector<Tensor<1, spacedim, VectorizedArrayType>> normal_vectors;
+ AlignedVector<Tensor<1, spacedim, Number>> normal_vectors;
/**
* The storage of covariant transformation on quadrature points, i.e.,
* but the default case (cell integrals or boundary integrals) only
* fills the zeroth component and ignores the first one.
*/
- std::array<AlignedVector<Tensor<2, spacedim, VectorizedArrayType>>, 2>
- jacobians;
+ std::array<AlignedVector<Tensor<2, spacedim, Number>>, 2> jacobians;
/**
* The storage of the gradients of the inverse Jacobian
* fills the zeroth component and ignores the first one.
*/
std::array<
- AlignedVector<Tensor<1,
- spacedim *(spacedim + 1) / 2,
- Tensor<1, spacedim, VectorizedArrayType>>>,
+ AlignedVector<
+ Tensor<1, spacedim *(spacedim + 1) / 2, Tensor<1, spacedim, Number>>>,
2>
jacobian_gradients;
*
* Indexed by @p data_index_offsets.
*/
- std::array<AlignedVector<Tensor<1, spacedim, VectorizedArrayType>>, 2>
+ std::array<AlignedVector<Tensor<1, spacedim, Number>>, 2>
normals_times_jacobians;
/**
*
* Indexed by @p quadrature_point_offsets.
*/
- AlignedVector<Point<spacedim, VectorizedArrayType>> quadrature_points;
+ AlignedVector<Point<spacedim, Number>> quadrature_points;
/**
* Clears all data fields except the descriptor vector.
* Get the descriptor from another instance of QuadratureDescriptor,
* clearing all other data fields.
*/
- template <typename Number2, typename VectorizedArrayType2>
+ template <typename Number2>
void
- copy_descriptor(const MappingInfoStorage<structdim,
- spacedim,
- Number2,
- VectorizedArrayType2> &other);
+ copy_descriptor(
+ const MappingInfoStorage<structdim, spacedim, Number2> &other);
+
+ /**
+ * Helper function to determine which update flags must be set in the
+ * internal functions to initialize all data as requested by the user.
+ */
+ static UpdateFlags
+ compute_update_flags(
+ const UpdateFlags update_flags,
+ const std::vector<dealii::hp::QCollection<spacedim>> &quad =
+ std::vector<dealii::hp::QCollection<spacedim>>());
/**
* Prints a detailed summary of memory consumption in the different
/* ------------------- inline functions ----------------------------- */
- template <int structdim,
- int spacedim,
- typename Number,
- typename VectorizedArrayType>
+ template <int structdim, int spacedim, typename Number>
inline unsigned int
- MappingInfoStorage<structdim, spacedim, Number, VectorizedArrayType>::
- quad_index_from_n_q_points(const unsigned int n_q_points) const
+ MappingInfoStorage<structdim, spacedim, Number>::quad_index_from_n_q_points(
+ const unsigned int n_q_points) const
{
for (unsigned int i = 0; i < descriptor.size(); ++i)
if (n_q_points == descriptor[i].n_q_points)
{
namespace MatrixFreeFunctions
{
- template <int structdim,
- int spacedim,
- typename Number,
- typename VectorizedArrayType>
- MappingInfoStorage<structdim, spacedim, Number, VectorizedArrayType>::
- QuadratureDescriptor::QuadratureDescriptor()
+ template <int structdim, int spacedim, typename Number>
+ MappingInfoStorage<structdim, spacedim, Number>::QuadratureDescriptor::
+ QuadratureDescriptor()
: n_q_points(numbers::invalid_unsigned_int)
{}
- template <int structdim,
- int spacedim,
- typename Number,
- typename VectorizedArrayType>
+ template <int structdim, int spacedim, typename Number>
template <int dim_q>
void
- MappingInfoStorage<structdim, spacedim, Number, VectorizedArrayType>::
- QuadratureDescriptor::initialize(
- const Quadrature<dim_q> &quadrature,
- const UpdateFlags update_flags_inner_faces)
+ MappingInfoStorage<structdim, spacedim, Number>::QuadratureDescriptor::
+ initialize(const Quadrature<dim_q> &quadrature,
+ const UpdateFlags update_flags_inner_faces)
{
Assert(structdim + 1 <= spacedim ||
update_flags_inner_faces == update_default,
- template <int structdim,
- int spacedim,
- typename Number,
- typename VectorizedArrayType>
+ template <int structdim, int spacedim, typename Number>
void
- MappingInfoStorage<structdim, spacedim, Number, VectorizedArrayType>::
- QuadratureDescriptor::initialize(
- const Quadrature<1> &quadrature_1d,
- const UpdateFlags update_flags_inner_faces)
+ MappingInfoStorage<structdim, spacedim, Number>::QuadratureDescriptor::
+ initialize(const Quadrature<1> &quadrature_1d,
+ const UpdateFlags update_flags_inner_faces)
{
Assert(structdim + 1 <= spacedim ||
update_flags_inner_faces == update_default,
- template <int structdim,
- int spacedim,
- typename Number,
- typename VectorizedArrayType>
+ template <int structdim, int spacedim, typename Number>
std::size_t
- MappingInfoStorage<structdim, spacedim, Number, VectorizedArrayType>::
- QuadratureDescriptor::memory_consumption() const
+ MappingInfoStorage<structdim, spacedim, Number>::QuadratureDescriptor::
+ memory_consumption() const
{
std::size_t memory = sizeof(this) + quadrature.memory_consumption() +
quadrature_weights.memory_consumption() +
- template <int structdim,
- int spacedim,
- typename Number,
- typename VectorizedArrayType>
+ template <int structdim, int spacedim, typename Number>
void
- MappingInfoStorage<structdim, spacedim, Number, VectorizedArrayType>::
- clear_data_fields()
+ MappingInfoStorage<structdim, spacedim, Number>::clear_data_fields()
{
data_index_offsets.clear();
JxW_values.clear();
- template <int structdim,
- int spacedim,
- typename Number,
- typename VectorizedArrayType>
- template <typename Number2, typename VectorizedArrayType2>
+ template <int structdim, int spacedim, typename Number>
+ template <typename Number2>
void
- MappingInfoStorage<structdim, spacedim, Number, VectorizedArrayType>::
- copy_descriptor(const MappingInfoStorage<structdim,
- spacedim,
- Number2,
- VectorizedArrayType2> &other)
+ MappingInfoStorage<structdim, spacedim, Number>::copy_descriptor(
+ const MappingInfoStorage<structdim, spacedim, Number2> &other)
{
clear_data_fields();
descriptor.clear();
- template <int structdim,
- int spacedim,
- typename Number,
- typename VectorizedArrayType>
+ template <int structdim, int spacedim, typename Number>
+ UpdateFlags
+ MappingInfoStorage<structdim, spacedim, Number>::compute_update_flags(
+ const UpdateFlags update_flags,
+ const std::vector<dealii::hp::QCollection<spacedim>> &quad)
+ {
+ // this class is build around the evaluation of jacobians, so compute
+ // them in any case. The Jacobians will be inverted manually. Since we
+ // always do support integration, we also include the JxW values
+ UpdateFlags new_flags = update_jacobians | update_JxW_values;
+
+ // for Hessian information, need inverse Jacobians and the derivative of
+ // Jacobians (these two together will give use the gradients of the
+ // inverse Jacobians, which is what we need)
+ if (update_flags & update_hessians ||
+ update_flags & update_jacobian_grads)
+ new_flags |= update_jacobian_grads;
+
+ if (update_flags & update_quadrature_points)
+ new_flags |= update_quadrature_points;
+
+ // there is one more thing: if we have a quadrature formula with only
+ // one quadrature point on the first component, but more points on later
+ // components, we need to have Jacobian gradients anyway in order to
+ // determine whether the Jacobian is constant throughout a cell
+ if (quad.empty() == false)
+ {
+ bool formula_with_one_point = false;
+ for (unsigned int i = 0; i < quad[0].size(); ++i)
+ if (quad[0][i].size() == 1)
+ {
+ formula_with_one_point = true;
+ break;
+ }
+ if (formula_with_one_point == true)
+ for (unsigned int comp = 1; comp < quad.size(); ++comp)
+ for (unsigned int i = 0; i < quad[comp].size(); ++i)
+ if (quad[comp][i].size() > 1)
+ {
+ new_flags |= update_jacobian_grads;
+ }
+ }
+ return new_flags;
+ }
+
+
+
+ template <int structdim, int spacedim, typename Number>
std::size_t
- MappingInfoStorage<structdim, spacedim, Number, VectorizedArrayType>::
- memory_consumption() const
+ MappingInfoStorage<structdim, spacedim, Number>::memory_consumption() const
{
return MemoryConsumption::memory_consumption(descriptor) +
MemoryConsumption::memory_consumption(data_index_offsets) +
- template <int structdim,
- int spacedim,
- typename Number,
- typename VectorizedArrayType>
+ template <int structdim, int spacedim, typename Number>
template <typename StreamType>
void
- MappingInfoStorage<structdim, spacedim, Number, VectorizedArrayType>::
- print_memory_consumption(StreamType &out, const TaskInfo &task_info) const
+ MappingInfoStorage<structdim, spacedim, Number>::print_memory_consumption(
+ StreamType & out,
+ const TaskInfo &task_info) const
{
// print_memory_statistics involves global communication, so we can
// disable the check here only if no processor has any such data
internal::CellwiseInverseMassMatrixImplBasic<dim, VectorizedArrayType>::
template run<fe_degree>(n_components, fe_eval, in_array, out_array);
else
- internal::CellwiseInverseMassFactory<dim, Number, VectorizedArrayType>::
- apply(n_components, fe_eval, in_array, out_array);
+ internal::CellwiseInverseMassFactory<dim, VectorizedArrayType>::apply(
+ n_components, fe_eval, in_array, out_array);
}
in_array,
out_array);
else
- internal::CellwiseInverseMassFactory<dim, Number, VectorizedArrayType>::
- apply(n_actual_components,
- given_degree,
- fe_eval.get_shape_info().data.front().inverse_shape_values_eo,
- inverse_coefficients,
- in_array,
- out_array);
+ internal::CellwiseInverseMassFactory<dim, VectorizedArrayType>::apply(
+ n_actual_components,
+ given_degree,
+ fe_eval.get_shape_info().data.front().inverse_shape_values_eo,
+ inverse_coefficients,
+ in_array,
+ out_array);
}
in_array,
out_array);
else
- internal::CellwiseInverseMassFactory<dim, Number, VectorizedArrayType>::
+ internal::CellwiseInverseMassFactory<dim, VectorizedArrayType>::
transform_from_q_points_to_basis(n_actual_components,
fe_eval,
in_array,
for (deal_II_dimension : DIMENSIONS;
deal_II_scalar_vectorized : REAL_SCALARS_VECTORIZED)
{
- template struct dealii::internal::FEEvaluationFactory<
- deal_II_dimension,
- deal_II_scalar_vectorized::value_type,
- deal_II_scalar_vectorized>;
+ template struct dealii::internal::
+ FEEvaluationFactory<deal_II_dimension, deal_II_scalar_vectorized>;
+
+ template struct dealii::internal::
+ FEFaceEvaluationFactory<deal_II_dimension, deal_II_scalar_vectorized>;
- template struct dealii::internal::FEFaceEvaluationFactory<
+ template struct dealii::internal::FEFaceEvaluationGatherFactory<
deal_II_dimension,
deal_II_scalar_vectorized::value_type,
deal_II_scalar_vectorized>;
// inverse mass
- template struct dealii::internal::CellwiseInverseMassFactory<
- deal_II_dimension,
- deal_II_scalar_vectorized::value_type,
- deal_II_scalar_vectorized>;
+ template struct dealii::internal::
+ CellwiseInverseMassFactory<deal_II_dimension, deal_II_scalar_vectorized>;
}
template struct internal::MatrixFreeFunctions::MappingInfoStorage<
deal_II_dimension,
deal_II_dimension,
- deal_II_scalar_vectorized::value_type,
deal_II_scalar_vectorized>;
#if deal_II_dimension > 1
template struct internal::MatrixFreeFunctions::MappingInfoStorage<
deal_II_dimension - 1,
deal_II_dimension,
- deal_II_scalar_vectorized::value_type,
deal_II_scalar_vectorized>;
#endif
projects / dealii.git / commitdiff