--- /dev/null
+Removed: The deprecated functions MatrixFree::n_macro_cells(),
+MatrixFree::get_hp_cell_iterator(), MatrixFree::n_components_filled(),
+MatrixFree::get_dof_handler(), and
+MatrixFree::reinit() with default Mapping argument have been removed.
+<br>
+(Daniel Arndt, 2022/06/22)
const QuadratureType & quad,
const AdditionalData & additional_data = AdditionalData());
- /**
- * Initializes the data structures. Same as above, but using a $Q_1$
- * mapping.
- *
- * @deprecated Use the overload taking a Mapping object instead.
- */
- template <typename QuadratureType, typename number2>
- DEAL_II_DEPRECATED void
- reinit(const DoFHandler<dim> & dof_handler,
- const AffineConstraints<number2> &constraint,
- const QuadratureType & quad,
- const AdditionalData & additional_data = AdditionalData());
-
/**
* Extracts the information needed to perform loops over cells. The
* DoFHandler and AffineConstraints objects describe the layout of degrees of
const std::vector<QuadratureType> & quad,
const AdditionalData &additional_data = AdditionalData());
- /**
- * Initializes the data structures. Same as above, but using a $Q_1$
- * mapping.
- *
- * @deprecated Use the overload taking a Mapping object instead.
- */
- template <typename QuadratureType, typename number2>
- DEAL_II_DEPRECATED void
- reinit(const std::vector<const DoFHandler<dim> *> & dof_handler,
- const std::vector<const AffineConstraints<number2> *> &constraint,
- const std::vector<QuadratureType> & quad,
- const AdditionalData &additional_data = AdditionalData());
-
/**
* Initializes the data structures. Same as before, but now the index set
* description of the locally owned range of degrees of freedom is taken
const QuadratureType & quad,
const AdditionalData &additional_data = AdditionalData());
- /**
- * Initializes the data structures. Same as above, but using a $Q_1$
- * mapping.
- *
- * @deprecated Use the overload taking a Mapping object instead.
- */
- template <typename QuadratureType, typename number2>
- DEAL_II_DEPRECATED void
- reinit(const std::vector<const DoFHandler<dim> *> & dof_handler,
- const std::vector<const AffineConstraints<number2> *> &constraint,
- const QuadratureType & quad,
- const AdditionalData &additional_data = AdditionalData());
-
/**
* Copy function. Creates a deep copy of all data structures. It is usually
* enough to keep the data for different operations once, so this function
unsigned int
n_physical_cells() const;
- /**
- * @deprecated Use n_cell_batches() instead.
- */
- DEAL_II_DEPRECATED unsigned int
- n_macro_cells() const;
-
/**
* Return the number of cell batches that this structure works on. The
* batches are formed by application of vectorization over several cells in
const bool interior = true,
const unsigned int fe_component = 0) const;
- /**
- * @copydoc MatrixFree::get_cell_iterator()
- *
- * @deprecated Use get_cell_iterator() instead.
- */
- DEAL_II_DEPRECATED typename DoFHandler<dim>::active_cell_iterator
- get_hp_cell_iterator(const unsigned int cell_batch_index,
- const unsigned int lane_index,
- const unsigned int dof_handler_index = 0) const;
-
/**
* Since this class uses vectorized data types with usually more than one
* value in the data field, a situation might occur when some components of
bool
at_irregular_cell(const unsigned int cell_batch_index) const;
- /**
- * @deprecated Use n_active_entries_per_cell_batch() instead.
- */
- DEAL_II_DEPRECATED unsigned int
- n_components_filled(const unsigned int cell_batch_number) const;
-
/**
* This query returns how many cells among the `VectorizedArrayType::size()`
* many cells within a cell batch to actual cells in the mesh, rather than
-template <int dim, typename Number, typename VectorizedArrayType>
-inline unsigned int
-MatrixFree<dim, Number, VectorizedArrayType>::n_macro_cells() const
-{
- return *(task_info.cell_partition_data.end() - 2);
-}
-
-
-
template <int dim, typename Number, typename VectorizedArrayType>
inline unsigned int
MatrixFree<dim, Number, VectorizedArrayType>::n_physical_cells() const
-template <int dim, typename Number, typename VectorizedArrayType>
-inline unsigned int
-MatrixFree<dim, Number, VectorizedArrayType>::n_components_filled(
- const unsigned int cell_batch_index) const
-{
- return n_active_entries_per_cell_batch(cell_batch_index);
-}
-
-
-
template <int dim, typename Number, typename VectorizedArrayType>
inline unsigned int
MatrixFree<dim, Number, VectorizedArrayType>::n_active_entries_per_cell_batch(
-template <int dim, typename Number, typename VectorizedArrayType>
-template <typename QuadratureType, typename number2>
-void
-MatrixFree<dim, Number, VectorizedArrayType>::reinit(
- const DoFHandler<dim> & dof_handler,
- const AffineConstraints<number2> &constraints_in,
- const QuadratureType & quad,
- const typename MatrixFree<dim, Number, VectorizedArrayType>::AdditionalData
- &additional_data)
-{
- std::vector<const DoFHandler<dim, dim> *> dof_handlers;
- std::vector<const AffineConstraints<number2> *> constraints;
- std::vector<QuadratureType> quads;
-
- dof_handlers.push_back(&dof_handler);
- constraints.push_back(&constraints_in);
- quads.push_back(quad);
-
- std::vector<IndexSet> locally_owned_sets =
- internal::MatrixFreeImplementation::extract_locally_owned_index_sets(
- dof_handlers, additional_data.mg_level);
-
- std::vector<hp::QCollection<dim>> quad_hp;
- quad_hp.emplace_back(quad);
-
- internal_reinit(std::make_shared<hp::MappingCollection<dim>>(
- StaticMappingQ1<dim>::mapping),
- dof_handlers,
- constraints,
- locally_owned_sets,
- quad_hp,
- additional_data);
-}
-
-
-
template <int dim, typename Number, typename VectorizedArrayType>
template <typename QuadratureType, typename number2, typename MappingType>
void
-template <int dim, typename Number, typename VectorizedArrayType>
-template <typename QuadratureType, typename number2>
-void
-MatrixFree<dim, Number, VectorizedArrayType>::reinit(
- const std::vector<const DoFHandler<dim> *> & dof_handler,
- const std::vector<const AffineConstraints<number2> *> &constraint,
- const std::vector<QuadratureType> & quad,
- const typename MatrixFree<dim, Number, VectorizedArrayType>::AdditionalData
- &additional_data)
-{
- std::vector<IndexSet> locally_owned_set =
- internal::MatrixFreeImplementation::extract_locally_owned_index_sets(
- dof_handler, additional_data.mg_level);
- std::vector<hp::QCollection<dim>> quad_hp;
- for (unsigned int q = 0; q < quad.size(); ++q)
- quad_hp.emplace_back(quad[q]);
-
- internal_reinit(std::make_shared<hp::MappingCollection<dim>>(
- StaticMappingQ1<dim>::mapping),
- dof_handler,
- constraint,
- locally_owned_set,
- quad_hp,
- additional_data);
-}
-
-
-
-template <int dim, typename Number, typename VectorizedArrayType>
-template <typename QuadratureType, typename number2>
-void
-MatrixFree<dim, Number, VectorizedArrayType>::reinit(
- const std::vector<const DoFHandler<dim> *> & dof_handler,
- const std::vector<const AffineConstraints<number2> *> &constraint,
- const QuadratureType & quad,
- const typename MatrixFree<dim, Number, VectorizedArrayType>::AdditionalData
- &additional_data)
-{
- std::vector<IndexSet> locally_owned_set =
- internal::MatrixFreeImplementation::extract_locally_owned_index_sets(
- dof_handler, additional_data.mg_level);
- std::vector<hp::QCollection<dim>> quad_hp;
- quad_hp.emplace_back(quad);
-
- internal_reinit(std::make_shared<hp::MappingCollection<dim>>(
- StaticMappingQ1<dim>::mapping),
- dof_handler,
- constraint,
- locally_owned_set,
- quad_hp,
- additional_data);
-}
-
-
-
template <int dim, typename Number, typename VectorizedArrayType>
template <typename QuadratureType, typename number2, typename MappingType>
void
-template <int dim, typename Number, typename VectorizedArrayType>
-typename DoFHandler<dim>::active_cell_iterator
-MatrixFree<dim, Number, VectorizedArrayType>::get_hp_cell_iterator(
- const unsigned int cell_batch_index,
- const unsigned int lane_index,
- const unsigned int dof_handler_index) const
-{
- AssertIndexRange(dof_handler_index, dof_handlers.size());
- AssertIndexRange(cell_batch_index, task_info.cell_partition_data.back());
- AssertIndexRange(lane_index,
- n_active_entries_per_cell_batch(cell_batch_index));
-
- std::pair<unsigned int, unsigned int> index =
- cell_level_index[cell_batch_index * VectorizedArrayType::size() +
- lane_index];
- return typename DoFHandler<dim>::cell_iterator(
- &dof_handlers[dof_handler_index]->get_triangulation(),
- index.first,
- index.second,
- &*dof_handlers[dof_handler_index]);
-}
-
-
-
template <int dim, typename Number, typename VectorizedArrayType>
void
MatrixFree<dim, Number, VectorizedArrayType>::copy_from(
MatrixFree<dim, double>::AdditionalData::partition_color;
data.mapping_update_flags =
update_values | update_gradients | update_JxW_values;
- mf_data->reinit(dof_handler, constraints, quad, data);
+ mf_data->reinit(MappingQ1<dim>{}, dof_handler, constraints, quad, data);
}
MatrixFree<dim, double>::AdditionalData::partition_color;
data.mapping_update_flags =
update_values | update_gradients | update_JxW_values;
- mf_data->reinit(dof_handler, constraints, quad, data);
+ mf_data->reinit(MappingQ1<dim>{}, dof_handler, constraints, quad, data);
}
std::vector<LinearAlgebra::distributed::Vector<double>> eigenfunctions;
MatrixFree<dim, double>::AdditionalData::partition_color;
data.mapping_update_flags =
update_values | update_gradients | update_JxW_values;
- mf_data->reinit(dof_handler, constraints, quad, data);
+ mf_data->reinit(MappingQ1<dim>{}, dof_handler, constraints, quad, data);
}
std::vector<LinearAlgebra::distributed::Vector<double>> eigenfunctions;
MatrixFree<dim, double>::AdditionalData::partition_color;
data.mapping_update_flags =
update_values | update_gradients | update_JxW_values;
- mf_data->reinit(dof_handler, constraints, quad, data);
+ mf_data->reinit(MappingQ1<dim>{}, dof_handler, constraints, quad, data);
}
MatrixFreeOperators::MassOperator<dim,
euler_fine, dof_handler, constraints, quadrature_formula, data);
MatrixFree<dim, NumberType> matrix_free;
- matrix_free.reinit(dof_handler, constraints, quadrature_formula, data);
+ matrix_free.reinit(
+ MappingQ1<dim>{}, dof_handler, constraints, quadrature_formula, data);
// test fine-level mapping:
euler_fine, dof_handler, constraints, quadrature_formula, data);
MatrixFree<dim, NumberType> matrix_free;
- matrix_free.reinit(dof_handler, constraints, quadrature_formula, data);
+ matrix_free.reinit(
+ MappingQ1<dim>{}, dof_handler, constraints, quadrature_formula, data);
// test fine-level mapping:
(update_gradients | update_JxW_values);
MatrixFree<dim, double> mf_data;
- mf_data.reinit(dof, constraints, quad, data);
+ mf_data.reinit(MappingQ1<dim>{}, dof, constraints, quad, data);
mf_data.initialize_dof_vector(in);
mf_data.initialize_dof_vector(out);
(update_gradients | update_JxW_values);
MatrixFree<dim, double> mf_data;
- mf_data.reinit(dof, constraints, quad, data);
+ mf_data.reinit(MappingQ1<dim>{}, dof, constraints, quad, data);
mf_data.initialize_dof_vector(in);
mf_data.initialize_dof_vector(out);
(update_gradients | update_JxW_values);
MatrixFree<dim, double> mf_data;
- mf_data.reinit(dof, constraints, quad, data);
+ mf_data.reinit(MappingQ1<dim>{}, dof, constraints, quad, data);
mf_data.initialize_dof_vector(in);
mf_data.initialize_dof_vector(out);
bool result = true;
MatrixFree<dim, double> data;
- data.reinit(dof_handler, dummy, quadrature, additional_data);
+ data.reinit(
+ MappingQ1<dim>{}, dof_handler, dummy, quadrature, additional_data);
using VectorType = Vector<double>;
static_cast<unsigned int>(cell->center()[1] * 10.);
data.cell_vectorization_categories_strict = false;
- mf_data.reinit(dof, constraints, QGauss<1>(2), data);
+ mf_data.reinit(MappingQ1<dim>{}, dof, constraints, QGauss<1>(2), data);
deallog << "Number of cell batches: " << mf_data.n_cell_batches()
<< std::endl;
deallog << std::endl;
data.cell_vectorization_categories_strict = true;
- mf_data.reinit(dof, constraints, QGauss<1>(2), data);
+ mf_data.reinit(MappingQ1<dim>{}, dof, constraints, QGauss<1>(2), data);
deallog << "Number of cell batches: " << mf_data.n_cell_batches()
<< std::endl;
for (unsigned int i = 0; i < mf_data.n_cell_batches(); ++i)
100000000);
data.cell_vectorization_categories_strict = false;
- mf_data.reinit(dof, constraints, QGauss<1>(2), data);
+ mf_data.reinit(MappingQ1<dim>{}, dof, constraints, QGauss<1>(2), data);
deallog << "Number of cell batches: " << mf_data.n_cell_batches()
<< std::endl;
for (unsigned int i = 0; i < mf_data.n_cell_batches(); ++i)
cell->material_id();
}
- mf_data.reinit(dof, constraints, QGauss<1>(2), data);
+ mf_data.reinit(MappingQ1<dim>{}, dof, constraints, QGauss<1>(2), data);
const unsigned int max_level = tria.n_global_levels() - 1;
std::vector<typename MatrixFree<dim, float>::AdditionalData>
mg_mf_data[level] = std::make_shared<MatrixFree<dim, float>>();
- mg_mf_data[level]->reinit(dof,
+ mg_mf_data[level]->reinit(MappingQ1<dim>{},
+ dof,
level_constraints,
QGauss<1>(2),
mg_additional_data[level]);
{
std::cout << "Compare active indices." << std::endl;
- mf_data->reinit(dof, constraints, quad, additional_data);
+ mf_data->reinit(MappingQ1<dim>{}, dof, constraints, quad, additional_data);
compare_indices(mf_data.get());
}
std::cout << "Compare level indices." << std::endl;
const unsigned int level = tria.n_global_levels() - 1;
additional_data.mg_level = level;
- mf_data->reinit(dof, constraints, quad, additional_data);
+ mf_data->reinit(MappingQ1<dim>{}, dof, constraints, quad, additional_data);
compare_indices(mf_data.get());
}
}
const QGauss<1> quad(2);
MatrixFree<dim> mf;
- mf.reinit(dof, constraints, quad);
+ mf.reinit(MappingQ1<dim>{}, dof, constraints, quad);
deallog << "Number of hanging nodes: " << constraints.n_constraints()
<< std::endl;
MatrixFree<dim> mf;
typename MatrixFree<dim>::AdditionalData data;
data.tasks_parallel_scheme = MatrixFree<dim>::AdditionalData::none;
- mf.reinit(dof, constraints, quad, data);
+ mf.reinit(MappingQ1<dim>{}, dof, constraints, quad, data);
const unsigned int n_cell_batches = mf.n_cell_batches();
std::vector<unsigned int> n_cell_types(4, 0);
MatrixFree<dim> mf;
typename MatrixFree<dim>::AdditionalData data;
data.tasks_parallel_scheme = MatrixFree<dim>::AdditionalData::none;
- mf.reinit(dof, constraints, quad, data);
+ mf.reinit(MappingQ1<dim>{}, dof, constraints, quad, data);
const unsigned int n_cell_batches = mf.n_cell_batches();
std::vector<unsigned int> n_cell_types(4, 0);
MatrixFree<dim> mf;
typename MatrixFree<dim>::AdditionalData data;
data.tasks_parallel_scheme = MatrixFree<dim>::AdditionalData::none;
- mf.reinit(dof, constraints, quad, data);
+ mf.reinit(MappingQ1<dim>{}, dof, constraints, quad, data);
const unsigned int n_cell_batches = mf.n_cell_batches();
std::vector<unsigned int> n_cell_types(4, 0);
data.mapping_update_flags_boundary_faces =
update_gradients | update_normal_vectors;
- mf.reinit(dof, constraints, quad, data);
+ mf.reinit(MappingQ1<dim>{}, dof, constraints, quad, data);
const unsigned int n_cell_batches = mf.n_cell_batches();
Assert(n_cell_batches > 1, ExcInternalError());
MatrixFree<dim, number> mf_data;
{
const QGauss<1> quad(fe_degree + 1);
- mf_data.reinit(dof,
+ mf_data.reinit(MappingQ1<dim>{},
+ dof,
constraints,
quad,
typename MatrixFree<dim, number>::AdditionalData(
(update_gradients | update_JxW_values);
MatrixFree<dim> mf_data;
- mf_data.reinit(dof, constraints, quad, data);
+ mf_data.reinit(MappingQ1<dim>{}, dof, constraints, quad, data);
LinearAlgebra::distributed::Vector<double> rhs, sol;
mf_data.initialize_dof_vector(rhs);
{
MatrixFree<dim> mf_data;
data.mg_level = level;
- mf_data.reinit(dof, constraints, quad, data);
+ mf_data.reinit(MappingQ1<dim>{}, dof, constraints, quad, data);
std::vector<unsigned int> n_inner_faces(2 * dim),
n_inner_other_faces(2 * dim), n_boundary_faces(2 * dim);
for (unsigned int f = 0; f < mf_data.n_inner_face_batches(); ++f)
typename MatrixFree<dim, number>::AdditionalData data;
data.tasks_parallel_scheme = MatrixFree<dim, number>::AdditionalData::none;
data.tasks_block_size = 7;
- mf_data->reinit(dof, constraints, quad, data);
+ mf_data->reinit(MappingQ1<dim>{}, dof, constraints, quad, data);
}
const unsigned int n_cells = mf_data->n_cell_batches();
typename MatrixFree<dim, number>::AdditionalData data;
data.tasks_parallel_scheme = MatrixFree<dim, number>::AdditionalData::none;
data.tasks_block_size = 7;
- mf_data->reinit(dof, constraints, quad, data);
+ mf_data->reinit(MappingQ1<dim>{}, dof, constraints, quad, data);
}
const unsigned int n_cells = mf_data->n_cell_batches();
const QGauss<1> quad(fe_degree + 1);
typename MatrixFree<dim, number>::AdditionalData data;
data.tasks_block_size = 8 / VectorizedArray<number>::size();
- mf_data.reinit(dof, constraints, quad, data);
+ mf_data.reinit(MappingQ1<dim>{}, dof, constraints, quad, data);
}
MatrixFreeTest<dim, fe_degree, number> mf(mf_data);
DoFTools::make_hanging_node_constraints(dof_handler, constraint);
constraint.close();
- matrix_free.reinit(dof_handler, constraint, QGauss<1>(4), data);
+ matrix_free.reinit(
+ MappingQ1<dim>{}, dof_handler, constraint, QGauss<1>(4), data);
LinearAlgebra::distributed::Vector<double> src;
matrix_free.initialize_dof_vector(src);
data.mapping_update_flags_boundary_faces =
(update_gradients | update_JxW_values);
- mf_data.reinit(dof, constraints, quad, data);
+ mf_data.reinit(MappingQ1<dim>{}, dof, constraints, quad, data);
}
MatrixFreeTest<dim, fe_degree, number> mf(mf_data);
data.mapping_update_flags_boundary_faces =
(update_gradients | update_JxW_values);
- mf_data.reinit(dof, constraints, quad, data);
+ mf_data.reinit(MappingQ1<dim>{}, dof, constraints, quad, data);
}
MatrixFreeTest<dim, fe_degree, number> mf(mf_data);
data.mapping_update_flags_boundary_faces =
(update_gradients | update_JxW_values);
- mf_data.reinit(dof, constraints, quad, data);
+ mf_data.reinit(MappingQ1<dim>{}, dof, constraints, quad, data);
}
MatrixFreeTest<dim, fe_degree, number> mf(mf_data);
deallog << "Checking " << fes[i]->get_name() << std::endl;
dof.distribute_dofs(*fes[i]);
MatrixFree<dim> matrix_free;
- matrix_free.reinit(dof,
+ matrix_free.reinit(MappingQ1<dim>{},
+ dof,
AffineConstraints<double>(),
QGauss<1>(degree + 3),
typename MatrixFree<dim>::AdditionalData());
typename MatrixFree<dim, number>::AdditionalData data;
data.tasks_parallel_scheme = MatrixFree<dim, number>::AdditionalData::none;
data.mapping_update_flags = update_gradients | update_hessians;
- mf_data.reinit(dof, constraints, quad, data);
+ mf_data.reinit(MappingQ1<dim>{}, dof, constraints, quad, data);
}
MatrixFreeTest<dim, fe_degree, fe_degree + 1, number> mf(mf_data);
data.mapping_update_flags_boundary_faces =
(update_gradients | update_JxW_values);
- mf_data.reinit(dof, constraints, quad, data);
+ mf_data.reinit(MappingQ1<dim>{}, dof, constraints, quad, data);
}
MatrixFreeTest<dim, fe_degree, double> mf(mf_data);
Vector<double> in(dof.n_dofs());
std::vector<Quadrature<1>> quad;
for (unsigned int no = 0; no < 2; ++no)
quad.push_back(QGauss<1>(fe_degree + 1 + no));
- mf_data.reinit(dof,
+ mf_data.reinit(MappingQ1<dim>{},
+ dof,
constraints,
quad,
typename MatrixFree<dim, number>::AdditionalData(
std::vector<Quadrature<1>> quad;
quad.push_back(QGauss<1>(1));
quad.push_back(QGauss<1>(fe_degree + 1));
- mf_data.reinit(dof,
+ mf_data.reinit(MappingQ1<dim>{},
+ dof,
constraints,
quad,
typename MatrixFree<dim, number>::AdditionalData(
typename MatrixFree<dim>::AdditionalData data;
data.tasks_parallel_scheme = MatrixFree<dim>::AdditionalData::none;
data.mapping_update_flags = update_gradients | update_hessians;
- mf_data.reinit(dof, constraints, quad, data);
+ mf_data.reinit(MappingQ1<dim>{}, dof, constraints, quad, data);
}
MatrixFreeTest<dim, fe_degree, double> mf(mf_data);
typename MatrixFree<dim>::AdditionalData data;
data.tasks_parallel_scheme = MatrixFree<dim>::AdditionalData::none;
data.mapping_update_flags = update_gradients | update_hessians;
- mf_data.reinit(dof, constraints, quad, data);
+ mf_data.reinit(MappingQ1<dim>{}, dof, constraints, quad, data);
}
MatrixFreeTest<dim, fe_degree, double> mf(mf_data);
typename MatrixFree<dim, number>::AdditionalData data;
data.tasks_parallel_scheme = MatrixFree<dim, number>::AdditionalData::none;
data.store_plain_indices = true;
- mf_data.reinit(dof, constraints, quad, data);
+ mf_data.reinit(MappingQ1<dim>{}, dof, constraints, quad, data);
}
MatrixFreeTest<dim, fe_degree, fe_degree + 1, number> mf(mf_data);
MatrixFree<dim, number> mf_data;
{
const QGauss<1> quad(fe_degree + 1);
- mf_data.reinit(dof,
+ mf_data.reinit(MappingQ1<dim>{},
+ dof,
constraints,
quad,
typename MatrixFree<dim, number>::AdditionalData(
data.tasks_parallel_scheme = MatrixFree<dim, number>::AdditionalData::none;
data.mapping_update_flags |= update_hessians;
const QGauss<1> quad(fe_degree + 1);
- mf_data.reinit(dof, constraints, quad, data);
+ mf_data.reinit(MappingQ1<dim>{}, dof, constraints, quad, data);
}
MatrixFreeTest<dim, fe_degree, number> mf(mf_data);
std::vector<Quadrature<1>> quad;
for (unsigned int no = 0; no < 2; ++no)
quad.push_back(QGauss<1>(fe_degree + 1 + no));
- mf_data.reinit(dof,
+ mf_data.reinit(MappingQ1<dim>{},
+ dof,
constraints,
quad,
typename MatrixFree<dim, number>::AdditionalData(
std::vector<Quadrature<1>> quad;
quad.push_back(QGauss<1>(1));
quad.push_back(QGauss<1>(fe_degree + 1));
- mf_data.reinit(dof,
+ mf_data.reinit(MappingQ1<dim>{},
+ dof,
constraints,
quad,
typename MatrixFree<dim, number>::AdditionalData(
update_gradients | update_hessians | update_quadrature_points;
data.mapping_update_flags_inner_faces =
update_gradients | update_hessians | update_quadrature_points;
- mf_data.reinit(dof, constraints, quad, data);
+ mf_data.reinit(MappingQ1<dim>{}, dof, constraints, quad, data);
}
MatrixFreeTest<dim, fe_degree, fe_degree + 1, number> mf(mf_data);
data.tasks_block_size = 3;
AffineConstraints<double> constraints;
- mf_data.reinit(dof, constraints, quad, data);
+ mf_data.reinit(MappingQ1<dim>{}, dof, constraints, quad, data);
}
MatrixFreeTest<dim, fe_degree, number> mf(mf_data);
AffineConstraints<double> dummy;
typename MatrixFree<dim>::AdditionalData additional_data;
additional_data.mapping_update_flags |= update_quadrature_points;
- matrix_free.reinit(dof, dummy, QGauss<1>(degree + 1), additional_data);
+ matrix_free.reinit(
+ MappingQ1<dim>{}, dof, dummy, QGauss<1>(degree + 1), additional_data);
FEEvaluation<dim, degree> fe_eval(matrix_free);
FEEvaluation<dim, degree> fe_eval_default(matrix_free);
data.tasks_block_size = 3;
AffineConstraints<double> constraints;
- mf_data.reinit(dof, constraints, quad, data);
+ mf_data.reinit(MappingQ1<dim>{}, dof, constraints, quad, data);
}
MatrixFreeTest<dim, fe_degree, number> mf(mf_data);
data.tasks_block_size = 3;
AffineConstraints<double> constraints;
- mf_data.reinit(dof, constraints, quad, data);
+ mf_data.reinit(MappingQ1<dim>{}, dof, constraints, quad, data);
}
MatrixFreeTest<dim, number> mf(mf_data);
typename MatrixFree<dim>::AdditionalData data;
data.tasks_parallel_scheme = MatrixFree<dim>::AdditionalData::none;
data.mapping_update_flags = update_JxW_values;
- mf_data.reinit(dof, constraints, quad, data);
+ mf_data.reinit(MappingQ1<dim>{}, dof, constraints, quad, data);
}
double error = 0, error2 = 0, abs = 0;
typename MatrixFree<dim, number>::AdditionalData data;
data.tasks_parallel_scheme = MatrixFree<dim, number>::AdditionalData::none;
data.tasks_block_size = 7;
- mf_data->reinit(dof, constraints, quad, data);
+ mf_data->reinit(MappingQ1<dim>{}, dof, constraints, quad, data);
}
MatrixFreeOperators::LaplaceOperator<
data.tasks_block_size = 7;
data.mapping_update_flags =
update_quadrature_points | update_gradients | update_JxW_values;
- mf_data->reinit(dof, constraints, quad, data);
+ mf_data->reinit(MappingQ1<dim>{}, dof, constraints, quad, data);
}
std::shared_ptr<Table<2, VectorizedArray<number>>> coefficient;
data.tasks_block_size = 7;
data.mapping_update_flags =
update_quadrature_points | update_gradients | update_JxW_values;
- mf_data->reinit(dof, constraints, quad, data);
+ mf_data->reinit(MappingQ1<dim>{}, dof, constraints, quad, data);
}
std::shared_ptr<Table<2, VectorizedArray<number>>> coefficient;
add_data.mapping_update_flags_boundary_faces =
update_values | update_JxW_values | update_quadrature_points;
add_data.overlap_communication_computation = overlap_communication;
- matrix_free.reinit(dof_handler,
+ matrix_free.reinit(MappingQ1<dim>{},
+ dof_handler,
constraints,
QGauss<1>(fe.degree + 1),
add_data);
update_JxW_values | update_quadrature_points;
add_data.mapping_update_flags_boundary_faces =
update_values | update_JxW_values | update_quadrature_points;
- matrix_free.reinit(dof_handler,
+ matrix_free.reinit(MappingQ1<dim>{},
+ dof_handler,
constraints,
QGauss<1>(fe.degree + 1),
add_data);
typename MatrixFree<dim, number>::AdditionalData data;
data.tasks_parallel_scheme = MatrixFree<dim, number>::AdditionalData::none;
data.tasks_block_size = 7;
- mf_data->reinit(dof, constraints, quad, data);
+ mf_data->reinit(MappingQ1<dim>{}, dof, constraints, quad, data);
}
MatrixFreeOperators::MassOperator<dim,
typename MatrixFree<dim, number>::AdditionalData data;
data.tasks_parallel_scheme = MatrixFree<dim, number>::AdditionalData::none;
data.tasks_block_size = 7;
- mf_data->reinit(dof, constraints, quad, data);
+ mf_data->reinit(MappingQ1<dim>{}, dof, constraints, quad, data);
}
MatrixFreeOperators::MassOperator<dim,
typename MatrixFree<dim, number>::AdditionalData data;
data.tasks_parallel_scheme = MatrixFree<dim, number>::AdditionalData::none;
data.tasks_block_size = 7;
- mf_data->reinit(dof, constraints, quad, data);
+ mf_data->reinit(MappingQ1<dim>{}, dof, constraints, quad, data);
}
MatrixFreeOperators::MassOperator<dim,
const QGauss<1> quad(2);
typename MatrixFree<dim, number>::AdditionalData data;
data.tasks_parallel_scheme = MatrixFree<dim, number>::AdditionalData::none;
- mf_data_0->reinit(dof, constraints_0, quad, data);
- mf_data_1->reinit(dof, constraints_1, quad, data);
+ mf_data_0->reinit(MappingQ1<dim>{}, dof, constraints_0, quad, data);
+ mf_data_1->reinit(MappingQ1<dim>{}, dof, constraints_1, quad, data);
{
std::vector<const DoFHandler<dim> *> dof_handlers(2, &dof);
std::vector<const AffineConstraints<double> *> constraint(2);
constraint[0] = &constraints_0;
constraint[1] = &constraints_1;
- mf_data_combined->reinit(dof_handlers, constraint, quad, data);
+ mf_data_combined->reinit(
+ MappingQ1<dim>{}, dof_handlers, constraint, quad, data);
}
MatrixFreeOperators::
typename MatrixFree<dim, number>::AdditionalData data;
data.tasks_parallel_scheme = MatrixFree<dim, number>::AdditionalData::none;
data.tasks_block_size = 7;
- mf_data.reinit(dof, constraints, quad, data);
+ mf_data.reinit(MappingQ1<dim>{}, dof, constraints, quad, data);
}
MatrixFreeTest<dim,
typename MatrixFree<dim, number>::AdditionalData data;
data.tasks_parallel_scheme = MatrixFree<dim, number>::AdditionalData::none;
data.tasks_block_size = 7;
- mf_data.reinit(dof, constraints, quad, data);
+ mf_data.reinit(MappingQ1<dim>{}, dof, constraints, quad, data);
}
MatrixFreeTest<dim,
}
data.tasks_block_size = 3;
- mf_data.reinit(dof, constraints, quad, data);
+ mf_data.reinit(MappingQ1<dim>{}, dof, constraints, quad, data);
MatrixFreeTest<dim,
fe_degree,
number,
typename MatrixFree<dim, number>::AdditionalData data;
data.tasks_parallel_scheme = MatrixFree<dim, number>::AdditionalData::none;
data.tasks_block_size = 7;
- mf_data.reinit(dof, constraints, quad, data);
+ mf_data.reinit(MappingQ1<dim>{}, dof, constraints, quad, data);
}
MatrixFreeTest<dim, fe_degree, number> mf(mf_data);
typename MatrixFree<dim, number>::AdditionalData data;
data.tasks_parallel_scheme = MatrixFree<dim, number>::AdditionalData::none;
data.tasks_block_size = 7;
- mf_data.reinit(dof, constraints, quad, data);
+ mf_data.reinit(MappingQ1<dim>{}, dof, constraints, quad, data);
}
MatrixFreeTest<dim, fe_degree, number> mf(mf_data);
data.tasks_block_size = 7;
data.mapping_update_flags |= update_hessians;
- mf_data.reinit(dof, constraints, quad, data);
+ mf_data.reinit(MappingQ1<dim>{}, dof, constraints, quad, data);
}
MatrixFreeTest<dim, fe_degree, number> mf(mf_data);
typename MatrixFree<dim, number>::AdditionalData data;
data.tasks_parallel_scheme = MatrixFree<dim, number>::AdditionalData::none;
data.tasks_block_size = 7;
- mf_data.reinit(dof, constraints, quad, data);
+ mf_data.reinit(MappingQ1<dim>{}, dof, constraints, quad, data);
}
MatrixFreeTest<dim,
data.tasks_parallel_scheme =
MatrixFree<dim, number>::AdditionalData::partition_color;
data.tasks_block_size = 7;
- mf_data.reinit(dof, constraints, quad, data);
+ mf_data.reinit(MappingQ1<dim>{}, dof, constraints, quad, data);
}
MatrixFreeTest<dim, fe_degree, number> mf(mf_data);
data.tasks_parallel_scheme =
MatrixFree<dim, number>::AdditionalData::partition_color;
data.tasks_block_size = 7;
- mf_data.reinit(dof, constraints, quad, data);
+ mf_data.reinit(MappingQ1<dim>{}, dof, constraints, quad, data);
}
MatrixFreeTest<dim, fe_degree, number> mf(mf_data);
typename MatrixFree<dim, number>::AdditionalData data;
data.tasks_parallel_scheme = MatrixFree<dim, number>::AdditionalData::none;
data.tasks_block_size = 7;
- mf_data.reinit(dof, constraints, quad, data);
+ mf_data.reinit(MappingQ1<dim>{}, dof, constraints, quad, data);
}
MatrixFreeTest<dim, fe_degree, number> mf(mf_data);
const QGauss<1> quad(fe_degree + 1);
typename MatrixFree<dim, number>::AdditionalData data;
data.tasks_parallel_scheme = MatrixFree<dim, number>::AdditionalData::none;
- mf_data.reinit(dof, constraints, quad, data);
+ mf_data.reinit(MappingQ1<dim>{}, dof, constraints, quad, data);
}
MatrixFreeTest<dim, fe_degree, number> mf(mf_data);
const QGauss<1> quad(fe_degree + 1);
typename MatrixFree<dim, number>::AdditionalData data;
data.tasks_parallel_scheme = MatrixFree<dim, number>::AdditionalData::none;
- mf_data.reinit(dof, constraints, quad, data);
+ mf_data.reinit(MappingQ1<dim>{}, dof, constraints, quad, data);
}
MatrixFreeVariant<dim,
typename MatrixFree<dim, number>::AdditionalData data;
data.tasks_parallel_scheme = MatrixFree<dim, number>::AdditionalData::none;
data.overlap_communication_computation = false;
- mf_data.reinit(dof, constraints, quad, data);
+ mf_data.reinit(MappingQ1<dim>{}, dof, constraints, quad, data);
}
MatrixFreeTest<dim,
// setup matrix-free structure
{
QGauss<1> quad(fe_degree + 1);
- mf_data.reinit(dof_handler_sca,
+ mf_data.reinit(MappingQ1<dim>{},
+ dof_handler_sca,
constraints,
quad,
typename MatrixFree<dim>::AdditionalData(
// setup matrix-free structure
{
QGauss<1> quad(fe_degree + 1);
- mf_data.reinit(dof_handler_sca,
+ mf_data.reinit(MappingQ1<dim>{},
+ dof_handler_sca,
constraints,
quad,
typename MatrixFree<dim>::AdditionalData(
data.mapping_update_flags_boundary_faces =
(update_gradients | update_JxW_values);
- mf_data.reinit(dof, constraints, quad, data);
+ mf_data.reinit(MappingQ1<mydim>{}, dof, constraints, quad, data);
mf_data.initialize_dof_vector(in);
mf_data.initialize_dof_vector(out);
mf_data.renumber_dofs(renumbering);
dof.renumber_dofs(renumbering);
- mf_data.reinit(dof, constraints, quad, data);
+ mf_data.reinit(MappingQ1<mydim>{}, dof, constraints, quad, data);
mf_data.initialize_dof_vector(in2);
mf_data.initialize_dof_vector(out2);
for (unsigned int i = 0; i < in.local_size(); ++i)
(update_gradients | update_JxW_values);
data.mapping_update_flags_boundary_faces =
(update_gradients | update_JxW_values);
- mf_data.reinit(dof_system, constraints, quad, data);
+ mf_data.reinit(MappingQ1<dim>{}, dof_system, constraints, quad, data);
mf_data.initialize_dof_vector(in);
mf_data.initialize_dof_vector(out);
// finally compare to a series of scalar problems
MatrixFree<dim, double> mf_data_scalar;
- mf_data_scalar.reinit(dof, constraints, quad, data);
+ mf_data_scalar.reinit(MappingQ1<dim>{}, dof, constraints, quad, data);
LinearAlgebra::distributed::Vector<double> in_small, out_small, ref_small;
mf_data_scalar.initialize_dof_vector(in_small);
(update_gradients | update_JxW_values);
data.initialize_mapping = false;
- mf_data.reinit(dof_system, constraints, quad, data);
+ mf_data.reinit(MappingQ1<dim>{}, dof_system, constraints, quad, data);
std::vector<types::global_dof_index> renumbering;
mf_data.renumber_dofs(renumbering);
dof_system.renumber_dofs(renumbering);
data.initialize_mapping = true;
- mf_data.reinit(dof_system, constraints, quad, data);
+ mf_data.reinit(MappingQ1<dim>{}, dof_system, constraints, quad, data);
mf_data.initialize_dof_vector(in);
mf_data.initialize_dof_vector(out);
// finally compare to a series of scalar problems
MatrixFree<dim, double> mf_data_scalar;
- mf_data_scalar.reinit(dof, constraints, quad, data);
+ mf_data_scalar.reinit(MappingQ1<dim>{}, dof, constraints, quad, data);
LinearAlgebra::distributed::Vector<double> in_small, out_small, ref_small;
mf_data_scalar.initialize_dof_vector(in_small);
(update_gradients | update_JxW_values);
data.mapping_update_flags_boundary_faces =
(update_gradients | update_JxW_values);
- mf_data.reinit(dof_system, constraints, quad, data);
+ mf_data.reinit(MappingQ1<dim>{}, dof_system, constraints, quad, data);
mf_data.initialize_dof_vector(in);
mf_data.initialize_dof_vector(out);
// finally compare to a series of scalar problems
MatrixFree<dim, double> mf_data_scalar;
- mf_data_scalar.reinit(dof, constraints, quad, data);
+ mf_data_scalar.reinit(MappingQ1<dim>{}, dof, constraints, quad, data);
LinearAlgebra::distributed::Vector<double> in_small, out_small, ref_small;
mf_data_scalar.initialize_dof_vector(in_small);
(update_gradients | update_JxW_values);
data.initialize_mapping = false;
- mf_data.reinit(dof_system, constraints, quad, data);
+ mf_data.reinit(MappingQ1<dim>{}, dof_system, constraints, quad, data);
std::vector<types::global_dof_index> renumbering;
mf_data.renumber_dofs(renumbering);
dof_system.renumber_dofs(renumbering);
data.initialize_mapping = true;
- mf_data.reinit(dof_system, constraints, quad, data);
+ mf_data.reinit(MappingQ1<dim>{}, dof_system, constraints, quad, data);
mf_data.initialize_dof_vector(in);
mf_data.initialize_dof_vector(out);
// finally compare to a series of scalar problems
MatrixFree<dim, double> mf_data_scalar;
- mf_data_scalar.reinit(dof, constraints, quad, data);
+ mf_data_scalar.reinit(MappingQ1<dim>{}, dof, constraints, quad, data);
LinearAlgebra::distributed::Vector<double> in_small, out_small, ref_small;
mf_data_scalar.initialize_dof_vector(in_small);
(update_gradients | update_JxW_values);
data.mapping_update_flags_boundary_faces =
(update_gradients | update_JxW_values);
- mf_data.reinit(dof_system, constraints, quad, data);
+ mf_data.reinit(MappingQ1<dim>{}, dof_system, constraints, quad, data);
mf_data.initialize_dof_vector(in);
mf_data.initialize_dof_vector(out);
// finally compare to a series of scalar problems
MatrixFree<dim, double> mf_data_scalar;
- mf_data_scalar.reinit(dof, constraints, quad, data);
+ mf_data_scalar.reinit(MappingQ1<dim>{}, dof, constraints, quad, data);
LinearAlgebra::distributed::Vector<double> in_small, out_small, ref_small;
mf_data_scalar.initialize_dof_vector(in_small);
(update_gradients | update_JxW_values);
data.mapping_update_flags_boundary_faces =
(update_gradients | update_JxW_values);
- mf_data.reinit(dof_system, constraints, quad, data);
+ mf_data.reinit(MappingQ1<dim>{}, dof_system, constraints, quad, data);
mf_data.initialize_dof_vector(in);
mf_data.initialize_dof_vector(out);
// finally compare to a series of scalar problems
MatrixFree<dim, double> mf_data_scalar;
- mf_data_scalar.reinit(dof, constraints, quad, data);
+ mf_data_scalar.reinit(MappingQ1<dim>{}, dof, constraints, quad, data);
LinearAlgebra::distributed::Vector<double> in_small, out_small, ref_small;
mf_data_scalar.initialize_dof_vector(in_small);
(update_gradients | update_JxW_values);
data.mapping_update_flags_boundary_faces =
(update_gradients | update_JxW_values);
- mf_data.reinit(dof_system, constraints, quad, data);
+ mf_data.reinit(MappingQ1<dim>{}, dof_system, constraints, quad, data);
mf_data.initialize_dof_vector(in);
mf_data.initialize_dof_vector(out);
// finally compare to a series of scalar problems
MatrixFree<dim, double> mf_data_scalar;
- mf_data_scalar.reinit(dof, constraints, quad, data);
+ mf_data_scalar.reinit(MappingQ1<dim>{}, dof, constraints, quad, data);
LinearAlgebra::distributed::Vector<double> in_small, out_small, ref_small;
mf_data_scalar.initialize_dof_vector(in_small);
MatrixFree<dim, number> mf_data;
typename MatrixFree<dim, number>::AdditionalData data;
data.tasks_parallel_scheme = MatrixFree<dim, number>::AdditionalData::none;
- mf_data.reinit(dof, constraints, quadrature_collection_mf, data);
+ mf_data.reinit(
+ MappingQ1<dim>{}, dof, constraints, quadrature_collection_mf, data);
MatrixFreeTestHP<dim, number> mf(mf_data);
// assemble sparse matrix with (\nabla v,
MatrixFree<dim, number> mf_data;
typename MatrixFree<dim, number>::AdditionalData data;
data.tasks_parallel_scheme = MatrixFree<dim, number>::AdditionalData::none;
- mf_data.reinit(dof, constraints, quadrature_collection_mf, data);
+ mf_data.reinit(
+ MappingQ1<dim>{}, dof, constraints, quadrature_collection_mf, data);
MatrixFreeTestHP<dim, number> mf(mf_data);
// assemble sparse matrix with (\nabla v,
MatrixFree<dim, number> mf_data;
typename MatrixFree<dim, number>::AdditionalData data;
data.tasks_parallel_scheme = MatrixFree<dim, number>::AdditionalData::none;
- mf_data.reinit(dof, constraints, quadrature_collection_mf, data);
+ mf_data.reinit(
+ MappingQ1<dim>{}, dof, constraints, quadrature_collection_mf, data);
MatrixFreeTestHP<dim, number> mf(mf_data);
// assemble sparse matrix with (\nabla v,
typename MatrixFree<dim, double>::AdditionalData data;
data.tasks_parallel_scheme =
MatrixFree<dim, double>::AdditionalData::none;
- mf_data.reinit(dof, constraints, quad, data);
+ mf_data.reinit(MappingQ1<dim>{}, dof, constraints, quad, data);
}
MatrixFreeTest<dim, fe_degree, double, Vector<double>, fe_degree + 1> mf(
typename MatrixFree<dim, double>::AdditionalData data;
data.tasks_parallel_scheme =
MatrixFree<dim, double>::AdditionalData::none;
- mf_data.reinit(dof, constraints, quad, data);
+ mf_data.reinit(MappingQ1<dim>{}, dof, constraints, quad, data);
}
MatrixFreeTest<dim, fe_degree, double, Vector<double>, fe_degree + 2> mf(
const QGauss<1> quad(fe_degree + 1);
typename MatrixFree<dim, number>::AdditionalData data;
data.tasks_parallel_scheme = MatrixFree<dim, number>::AdditionalData::none;
- mf_data.reinit(dof, constraints, quad, data);
+ mf_data.reinit(MappingQ1<dim>{}, dof, constraints, quad, data);
}
MatrixFreeTest<dim, fe_degree, number, Vector<number>> mf(mf_data);
typename MatrixFree<dim, double>::AdditionalData data;
data.tasks_parallel_scheme =
MatrixFree<dim, double>::AdditionalData::none;
- mf_data.reinit(dof, constraints, quad, data);
+ mf_data.reinit(MappingQ1<dim>{}, dof, constraints, quad, data);
}
MatrixFreeTest<dim, fe_degree, double, Vector<double>, fe_degree + 1> mf(
MatrixFree<dim, double> mf_data;
{
- mf_data.reinit(dof, constraints, QGauss<1>(fe_degree + 2), data);
+ mf_data.reinit(
+ MappingQ1<dim>{}, dof, constraints, QGauss<1>(fe_degree + 2), data);
MatrixFreeTest<dim, fe_degree, double, Vector<double>, fe_degree + 2> mf(
mf_data);
mf.vmult(out, in);
// unfortunately we cannot use for loops due to the template, so duplicate
// some code here
{
- mf_data.reinit(dof, constraints, QGauss<1>(100), data);
+ mf_data.reinit(MappingQ1<dim>{}, dof, constraints, QGauss<1>(100), data);
MatrixFreeTest<dim, fe_degree, double, Vector<double>, 100> mf(mf_data);
mf.vmult(out, in);
out -= ref;
<< " quadrature points: " << out.l2_norm() << std::endl;
}
{
- mf_data.reinit(dof, constraints, QGauss<1>(200), data);
+ mf_data.reinit(MappingQ1<dim>{}, dof, constraints, QGauss<1>(200), data);
MatrixFreeTest<dim, fe_degree, double, Vector<double>, 200> mf(mf_data);
mf.vmult(out, in);
out -= ref;
<< " quadrature points: " << out.l2_norm() << std::endl;
}
{
- mf_data.reinit(dof, constraints, QGauss<1>(500), data);
+ mf_data.reinit(MappingQ1<dim>{}, dof, constraints, QGauss<1>(500), data);
MatrixFreeTest<dim, fe_degree, double, Vector<double>, 500> mf(mf_data);
mf.vmult(out, in);
out -= ref;
<< " quadrature points: " << out.l2_norm() << std::endl;
}
{
- mf_data.reinit(dof, constraints, QGauss<1>(1000), data);
+ mf_data.reinit(MappingQ1<dim>{}, dof, constraints, QGauss<1>(1000), data);
MatrixFreeTest<dim, fe_degree, double, Vector<double>, 1000> mf(mf_data);
mf.vmult(out, in);
out -= ref;
constraints.push_back(&dummy_constraints);
constraints.push_back(&dummy_constraints);
QGauss<1> quad(fe_degree + 2);
- mf_data.reinit(dofs,
+ mf_data.reinit(MappingQ1<dim>{},
+ dofs,
constraints,
quad,
typename MatrixFree<dim>::AdditionalData(
constraints.push_back(&constraints_p);
QGauss<1> quad(degree + 2);
// no parallelism
- mf_data->reinit(dofs,
+ mf_data->reinit(MappingQ1<dim>{},
+ dofs,
constraints,
quad,
typename MatrixFree<dim>::AdditionalData(
{
QGauss<1> quad(fe_degree + 2);
// no parallelism
- mf_data.reinit(dof_handler,
+ mf_data.reinit(MappingQ1<dim>{},
+ dof_handler,
constraints,
quad,
typename MatrixFree<dim>::AdditionalData(
constraints.push_back(&dummy_constraints);
constraints.push_back(&dummy_constraints);
QGauss<1> quad(fe_degree + 2);
- mf_data.reinit(dofs,
+ mf_data.reinit(MappingQ1<dim>{},
+ dofs,
constraints,
quad,
typename MatrixFree<dim>::AdditionalData(
constraints.push_back(&dummy_constraints);
constraints.push_back(&dummy_constraints);
QGauss<1> quad(fe_degree + 2);
- mf_data.reinit(dofs,
+ mf_data.reinit(MappingQ1<dim>{},
+ dofs,
constraints,
quad,
typename MatrixFree<dim>::AdditionalData(
data.tasks_parallel_scheme = MatrixFree<dim, number>::AdditionalData::none;
data.mapping_update_flags = update_gradients | update_hessians;
data.initialize_indices = false;
- mf_data.reinit(dof, constraints, quad, data);
+ mf_data.reinit(MappingQ1<dim>{}, dof, constraints, quad, data);
}
deallog << "Testing " << dof.get_fe().get_name() << " without read"
AffineConstraints<double> dummy;
dummy.close();
- data.reinit(dof_handler, dummy, quadrature, additional_data);
+ data.reinit(
+ MappingQ1<dim>{}, dof_handler, dummy, quadrature, additional_data);
using VectorType = LinearAlgebra::distributed::Vector<double>;
AffineConstraints<double> dummy;
dummy.close();
- data.reinit(dof_handler, dummy, quadrature, additional_data);
+ data.reinit(
+ MappingQ1<dim>{}, dof_handler, dummy, quadrature, additional_data);
using VectorType = LinearAlgebra::distributed::Vector<double>;
const QGauss<1> quad(fe_degree + 1);
typename MatrixFree<dim, number>::AdditionalData data;
data.tasks_parallel_scheme = MatrixFree<dim, number>::AdditionalData::none;
- mf_data.reinit(dof, constraints, quad, data);
+ mf_data.reinit(MappingQ1<dim>{}, dof, constraints, quad, data);
}
Matrix<dim, fe_degree, fe_degree + 1, number> mf(mf_data);
const QGauss<1> quad(fe_degree + 1);
typename MatrixFree<dim, number>::AdditionalData data;
data.tasks_parallel_scheme = MatrixFree<dim, number>::AdditionalData::none;
- mf_data.reinit(dof, constraints, quad, data);
+ mf_data.reinit(MappingQ1<dim>{}, dof, constraints, quad, data);
}
Matrix<dim, fe_degree, fe_degree + 1, number> mf(mf_data);
const QGauss<1> quad(fe_degree + 1);
typename MatrixFree<dim, number>::AdditionalData data;
data.tasks_parallel_scheme = MatrixFree<dim, number>::AdditionalData::none;
- mf_data.reinit(dof, constraints, quad, data);
+ mf_data.reinit(MappingQ1<dim>{}, dof, constraints, quad, data);
}
Matrix<dim, fe_degree, fe_degree + 1, number> mf(mf_data);
const QGauss<1> quad(fe_degree + 1);
typename MatrixFree<dim, number>::AdditionalData data;
data.tasks_parallel_scheme = MatrixFree<dim, number>::AdditionalData::none;
- mf_data.reinit(dof, constraints, quad, data);
+ mf_data.reinit(MappingQ1<dim>{}, dof, constraints, quad, data);
}
Matrix<dim, fe_degree, fe_degree + 1, number> mf(mf_data);
typename MatrixFree<dim, number>::AdditionalData data;
data.tasks_parallel_scheme =
MatrixFree<dim, number>::AdditionalData::partition_partition;
- mf_data.reinit(dof, constraints, quad, data);
+ mf_data.reinit(MappingQ1<dim>{}, dof, constraints, quad, data);
}
Matrix<dim, fe_degree, fe_degree + 1, number> mf(mf_data);
(update_gradients | update_JxW_values | update_quadrature_points);
std::shared_ptr<MatrixFree<dim, double>> system_mf_storage(
new MatrixFree<dim, double>());
- system_mf_storage->reinit(dof_handler,
+ system_mf_storage->reinit(MappingQ1<dim>{},
+ dof_handler,
constraints,
QGauss<1>(fe.degree + 1),
additional_data);
additional_data.mg_level = level;
std::shared_ptr<MatrixFree<dim, float>> mg_mf_storage_level(
new MatrixFree<dim, float>());
- mg_mf_storage_level->reinit(dof_handler,
+ mg_mf_storage_level->reinit(MappingQ1<dim>{},
+ dof_handler,
level_constraints,
QGauss<1>(fe.degree + 1),
additional_data);
additional_data.mg_level = level;
additional_data.mapping_update_flags =
(update_gradients | update_JxW_values | update_quadrature_points);
- data.reinit(dof_handler,
+ data.reinit(MappingQ1<dim>{},
+ dof_handler,
constraints,
QGauss<1>(fe_degree + 1),
additional_data);
additional_data.tasks_parallel_scheme =
MatrixFree<dim>::AdditionalData::partition_partition;
- matrix_free_data.reinit(dof_handler,
- constraints,
- quadrature,
- additional_data);
+ matrix_free_data.reinit(
+ MappingQ1<dim>{}, dof_handler, constraints, quadrature, additional_data);
matrix_free_data.initialize_dof_vector(solution);
old_solution.reinit(solution);
additional_data.tasks_parallel_scheme =
MatrixFree<dim>::AdditionalData::none;
- matrix_free_data.reinit(dof_handler,
- constraints,
- quadrature,
- additional_data);
+ matrix_free_data.reinit(
+ MappingQ1<dim>{}, dof_handler, constraints, quadrature, additional_data);
matrix_free_data.initialize_dof_vector(solution);
old_solution.reinit(solution);
additional_data.tasks_parallel_scheme =
MatrixFree<dim>::AdditionalData::partition_partition;
- matrix_free_data.reinit(dof_handler,
- constraints,
- quadrature,
- additional_data);
+ matrix_free_data.reinit(
+ MappingQ1<dim>{}, dof_handler, constraints, quadrature, additional_data);
matrix_free_data.initialize_dof_vector(solution);
old_solution.reinit(solution);
(update_values | update_JxW_values | update_quadrature_points);
std::shared_ptr<MatrixFree<dim, double>> mass_mf_storage(
new MatrixFree<dim, double>());
- mass_mf_storage->reinit(dof_handler_p,
+ mass_mf_storage->reinit(MappingQ1<dim>{},
+ dof_handler_p,
constraints_p,
QGauss<1>(degree_u + 1),
additional_data_mass);
additional_data.mg_level = level;
std::shared_ptr<MatrixFree<dim, double>> mg_mf_storage_level(
new MatrixFree<dim, double>());
- mg_mf_storage_level->reinit(dof_handler_u,
+ mg_mf_storage_level->reinit(MappingQ1<dim>{},
+ dof_handler_u,
level_constraints,
QGauss<1>(degree_u + 1),
additional_data);
MatrixFree<dim, number> mf_data, mf_data_color, mf_data_partition;
{
const QGauss<1> quad(fe_degree + 1);
- mf_data.reinit(dof,
+ mf_data.reinit(MappingQ1<dim>{},
+ dof,
constraints,
quad,
typename MatrixFree<dim, number>::AdditionalData(
// some irregularity to the blocks (stress the
// non-overlapping computation harder)
mf_data_color.reinit(
+ MappingQ1<dim>{},
dof,
constraints,
quad,
typename MatrixFree<dim, number>::AdditionalData(
MatrixFree<dim, number>::AdditionalData::partition_color, 3));
mf_data_partition.reinit(
+ MappingQ1<dim>{},
dof,
constraints,
quad,
MatrixFree<dim, number> mf_data, mf_data_color, mf_data_partition;
{
const QGauss<1> quad(fe_degree + 1);
- mf_data.reinit(dof,
+ mf_data.reinit(MappingQ1<dim>{},
+ dof,
constraints,
quad,
typename MatrixFree<dim, number>::AdditionalData(
// some irregularity to the blocks (stress the
// non-overlapping computation harder)
mf_data_color.reinit(
+ MappingQ1<dim>{},
dof,
constraints,
quad,
MatrixFree<dim, number>::AdditionalData::partition_color, 3));
mf_data_partition.reinit(
+ MappingQ1<dim>{},
dof,
constraints,
quad,
MatrixFree<dim, number> mf_data;
typename MatrixFree<dim, number>::AdditionalData data;
data.tasks_parallel_scheme = MatrixFree<dim, number>::AdditionalData::none;
- mf_data.reinit(dof, constraints, quadrature_collection_mf, data);
+ mf_data.reinit(
+ MappingQ1<dim>{}, dof, constraints, quadrature_collection_mf, data);
MatrixFreeTestHP<dim, number> mf(mf_data);
// test different block sizes, starting from
deallog << "Parallel option partition/color" << std::endl;
}
data.tasks_block_size = 1;
- mf_data_par.reinit(dof, constraints, quadrature_collection_mf, data);
+ mf_data_par.reinit(
+ MappingQ1<dim>{}, dof, constraints, quadrature_collection_mf, data);
MatrixFreeTestHP<dim, number> mf_par(mf_data_par);
// fill a right hand side vector with random
typename MatrixFree<dim, number>::AdditionalData data;
data.tasks_parallel_scheme = MatrixFree<dim, number>::AdditionalData::none;
data.tasks_block_size = 7;
- mf_data->reinit(dof, constraints, quad, data);
+ mf_data->reinit(MappingQ1<dim>{}, dof, constraints, quad, data);
}
MatrixFreeOperators::MassOperator<dim,
typename MatrixFree<dim, number>::AdditionalData data;
data.tasks_parallel_scheme = MatrixFree<dim, number>::AdditionalData::none;
data.tasks_block_size = 7;
- mf_data->reinit(dof, constraints, quad, data);
+ mf_data->reinit(MappingQ1<dim>{}, dof, constraints, quad, data);
}
MatrixFreeOperators::MassOperator<dim,
typename MatrixFree<dim, number>::AdditionalData data;
data.tasks_parallel_scheme = MatrixFree<dim, number>::AdditionalData::none;
data.tasks_block_size = 7;
- mf_data->reinit(dof, constraints, quad, data);
+ mf_data->reinit(MappingQ1<dim>{}, dof, constraints, quad, data);
}
MatrixFreeOperators::MassOperator<dim,
typename MatrixFree<dim, number>::AdditionalData data;
data.tasks_parallel_scheme = MatrixFree<dim, number>::AdditionalData::none;
data.tasks_block_size = 7;
- mf_data->reinit(dof, constraints, quad, data);
+ mf_data->reinit(MappingQ1<dim>{}, dof, constraints, quad, data);
}
MatrixFreeOperators::MassOperator<dim,
typename MatrixFree<dim, number>::AdditionalData data;
data.tasks_parallel_scheme = MatrixFree<dim, number>::AdditionalData::none;
data.tasks_block_size = 7;
- mf_data->reinit(dof, constraints, quad, data);
+ mf_data->reinit(MappingQ1<dim>{}, dof, constraints, quad, data);
}
MatrixFreeOperators::MassOperator<dim,
typename MatrixFree<dim, number>::AdditionalData data;
data.tasks_parallel_scheme = MatrixFree<dim, number>::AdditionalData::none;
data.tasks_block_size = 7;
- mf_data->reinit(dof, constraints, quad, data);
+ mf_data->reinit(MappingQ1<dim>{}, dof, constraints, quad, data);
}
MatrixFreeOperators::MassOperator<dim,
typename MatrixFree<dim, number>::AdditionalData data;
data.tasks_parallel_scheme = MatrixFree<dim, number>::AdditionalData::none;
data.tasks_block_size = 7;
- mf_data->reinit(dof, constraints, quad, data);
+ mf_data->reinit(MappingQ1<dim>{}, dof, constraints, quad, data);
}
MatrixFreeOperators::MassOperator<dim,
typename MatrixFree<dim, number>::AdditionalData data;
data.tasks_parallel_scheme = MatrixFree<dim, number>::AdditionalData::none;
data.tasks_block_size = 7;
- mf_data->reinit(dof, constraints, quad, data);
+ mf_data->reinit(MappingQ1<dim>{}, dof, constraints, quad, data);
}
MatrixFreeOperators::MassOperator<dim,
additional_data.mg_level = level;
std::shared_ptr<MatrixFree<dim, float>> mg_mf_storage_level(
new MatrixFree<dim, float>());
- mg_mf_storage_level->reinit(dof_handler,
+ mg_mf_storage_level->reinit(MappingQ1<dim>{},
+ dof_handler,
level_constraints,
QGauss<1>(fe.degree + 1),
additional_data);
projects / dealii.git / commitdiff