-template <int dim,
- int fe_degree,
- int n_q_points_1d = fe_degree + 1,
- typename number = double>
+template <int dim, typename number = double>
class LaplaceOperator : public Subscriptor
{
public:
void
initialize(const Mapping<dim> & mapping,
const DoFHandler<dim> &dof_handler,
+ const unsigned int n_q_points_1d,
const unsigned int level = numbers::invalid_unsigned_int)
{
+ fe_degree = dof_handler.get_fe().degree;
+
const QGauss<1> quad(n_q_points_1d);
typename MatrixFree<dim, number>::AdditionalData addit_data;
addit_data.tasks_parallel_scheme =
const LinearAlgebra::distributed::Vector<number> &src,
const std::pair<unsigned int, unsigned int> &cell_range) const
{
- FEEvaluation<dim, fe_degree, n_q_points_1d, 1, number> phi(data);
+ FEEvaluation<dim, -1, 0, 1, number> phi(data);
for (unsigned int cell = cell_range.first; cell < cell_range.second; ++cell)
{
const LinearAlgebra::distributed::Vector<number> &src,
const std::pair<unsigned int, unsigned int> & face_range) const
{
- FEFaceEvaluation<dim, fe_degree, n_q_points_1d, 1, number> fe_eval(data,
- true);
- FEFaceEvaluation<dim, fe_degree, n_q_points_1d, 1, number> fe_eval_neighbor(
- data, false);
+ FEFaceEvaluation<dim, -1, 0, 1, number> fe_eval(data, true);
+ FEFaceEvaluation<dim, -1, 0, 1, number> fe_eval_neighbor(data, false);
for (unsigned int face = face_range.first; face < face_range.second; face++)
{
const LinearAlgebra::distributed::Vector<number> &src,
const std::pair<unsigned int, unsigned int> & face_range) const
{
- FEFaceEvaluation<dim, fe_degree, n_q_points_1d, 1, number> fe_eval(data,
- true);
+ FEFaceEvaluation<dim, -1, 0, 1, number> fe_eval(data, true);
for (unsigned int face = face_range.first; face < face_range.second; face++)
{
fe_eval.reinit(face);
const unsigned int &,
const std::pair<unsigned int, unsigned int> &cell_range) const
{
- FEEvaluation<dim, fe_degree, n_q_points_1d, 1, number> phi(data);
+ FEEvaluation<dim, -1, 0, 1, number> phi(data);
+ AlignedVector<VectorizedArray<number>> local_diagonal_vector(
+ phi.dofs_per_cell);
for (unsigned int cell = cell_range.first; cell < cell_range.second; ++cell)
{
phi.reinit(cell);
- VectorizedArray<number> local_diagonal_vector[phi.static_dofs_per_cell];
for (unsigned int i = 0; i < phi.dofs_per_cell; ++i)
{
for (unsigned int j = 0; j < phi.dofs_per_cell; ++j)
phi.integrate(EvaluationFlags::gradients);
local_diagonal_vector[i] = phi.begin_dof_values()[i];
}
- for (unsigned int i = 0; i < phi.static_dofs_per_cell; ++i)
+ for (unsigned int i = 0; i < phi.dofs_per_cell; ++i)
phi.begin_dof_values()[i] = local_diagonal_vector[i];
phi.distribute_local_to_global(dst);
}
const unsigned int &,
const std::pair<unsigned int, unsigned int> &face_range) const
{
- FEFaceEvaluation<dim, fe_degree, n_q_points_1d, 1, number> phi(data, true);
- FEFaceEvaluation<dim, fe_degree, n_q_points_1d, 1, number> phi_outer(data,
- false);
+ FEFaceEvaluation<dim, -1, 0, 1, number> phi(data, true);
+ FEFaceEvaluation<dim, -1, 0, 1, number> phi_outer(data, false);
+ AlignedVector<VectorizedArray<number>> local_diagonal_vector(
+ phi.dofs_per_cell);
for (unsigned int face = face_range.first; face < face_range.second; face++)
{
phi.reinit(face);
phi_outer.reinit(face);
- VectorizedArray<number> local_diagonal_vector[phi.static_dofs_per_cell];
VectorizedArray<number> sigmaF =
(std::abs(
(phi.get_normal_vector(0) * phi.inverse_jacobian(0))[dim - 1]) +
const unsigned int &,
const std::pair<unsigned int, unsigned int> &face_range) const
{
- FEFaceEvaluation<dim, fe_degree, n_q_points_1d, 1, number> phi(data);
+ FEFaceEvaluation<dim, -1, 0, 1, number> phi(data);
+ AlignedVector<VectorizedArray<number>> local_diagonal_vector(
+ phi.dofs_per_cell);
for (unsigned int face = face_range.first; face < face_range.second; face++)
{
phi.reinit(face);
- VectorizedArray<number> local_diagonal_vector[phi.static_dofs_per_cell];
VectorizedArray<number> sigmaF =
std::abs(
(phi.get_normal_vector(0) * phi.inverse_jacobian(0))[dim - 1]) *
MatrixFree<dim, number> data;
LinearAlgebra::distributed::Vector<number> inverse_diagonal_entries;
+ int fe_degree;
};
-template <int dim, int fe_degree, int n_q_points_1d, typename number>
+template <int dim, typename number>
void
-do_test(const DoFHandler<dim> &dof)
+do_test(const DoFHandler<dim> &dof, const unsigned int n_q_points_1d)
{
deallog << "Testing " << dof.get_fe().get_name();
deallog << std::endl;
deallog << "Number of degrees of freedom: " << dof.n_dofs() << std::endl;
- MappingQ<dim> mapping(fe_degree + 1);
- LaplaceOperator<dim, fe_degree, n_q_points_1d, number> fine_matrix;
- fine_matrix.initialize(mapping, dof);
+ MappingQ<dim> mapping(n_q_points_1d);
+ LaplaceOperator<dim, number> fine_matrix;
+ fine_matrix.initialize(mapping, dof, n_q_points_1d);
LinearAlgebra::distributed::Vector<number> in, sol;
fine_matrix.initialize_dof_vector(in);
in = 1.;
// set up multigrid in analogy to step-37
- typedef LaplaceOperator<dim, fe_degree, n_q_points_1d, number>
- LevelMatrixType;
+ typedef LaplaceOperator<dim, number> LevelMatrixType;
MGLevelObject<LevelMatrixType> mg_matrices;
mg_matrices.resize(0, dof.get_triangulation().n_global_levels() - 1);
for (unsigned int level = 0;
level < dof.get_triangulation().n_global_levels();
++level)
- mg_matrices[level].initialize(mapping, dof, level);
+ mg_matrices[level].initialize(mapping, dof, n_q_points_1d, level);
MGCoarseIterative<LevelMatrixType, number> mg_coarse;
-template <int dim, int fe_degree>
+template <int dim>
void
-test()
+test(const unsigned int fe_degree)
{
- for (int i = 5; i < 9 - fe_degree; ++i)
+ for (unsigned int i = 5; i < 9 - fe_degree; ++i)
{
parallel::distributed::Triangulation<dim> tria(
MPI_COMM_WORLD,
dof.distribute_dofs(fe);
dof.distribute_mg_dofs();
- do_test<dim, fe_degree, fe_degree + 1, double>(dof);
+ do_test<dim, double>(dof, fe_degree + 1);
}
}
{
deallog.push("2d");
- test<2, 1>();
- test<2, 2>();
+ test<2>(1);
+ test<2>(2);
deallog.pop();
deallog.push("3d");
- test<3, 1>();
- test<3, 2>();
+ test<3>(1);
+ test<3>(2);
deallog.pop();
}
}
-template <int dim,
- int fe_degree,
- int n_q_points_1d = fe_degree + 1,
- typename number = double>
+template <int dim, typename number = double>
class LaplaceOperator : public Subscriptor
{
public:
void
initialize(const Mapping<dim> & mapping,
const DoFHandler<dim> &dof_handler,
+ const unsigned int n_q_points_1d,
const unsigned int level = numbers::invalid_unsigned_int)
{
+ fe_degree = dof_handler.get_fe().degree;
+
const QGauss<1> quad(n_q_points_1d);
typename MatrixFree<dim, number>::AdditionalData addit_data;
addit_data.tasks_parallel_scheme =
const LinearAlgebra::distributed::Vector<number> &src,
const std::pair<unsigned int, unsigned int> &cell_range) const
{
- FEEvaluation<dim, fe_degree, n_q_points_1d, 1, number> phi(data);
+ FEEvaluation<dim, -1, 0, 1, number> phi(data);
for (unsigned int cell = cell_range.first; cell < cell_range.second; ++cell)
{
const LinearAlgebra::distributed::Vector<number> &src,
const std::pair<unsigned int, unsigned int> & face_range) const
{
- FEFaceEvaluation<dim, fe_degree, n_q_points_1d, 1, number> fe_eval(data,
- true);
- FEFaceEvaluation<dim, fe_degree, n_q_points_1d, 1, number> fe_eval_neighbor(
- data, false);
+ FEFaceEvaluation<dim, -1, 0, 1, number> fe_eval(data, true);
+ FEFaceEvaluation<dim, -1, 0, 1, number> fe_eval_neighbor(data, false);
for (unsigned int face = face_range.first; face < face_range.second; face++)
{
const LinearAlgebra::distributed::Vector<number> &src,
const std::pair<unsigned int, unsigned int> & face_range) const
{
- FEFaceEvaluation<dim, fe_degree, n_q_points_1d, 1, number> fe_eval(data,
- true);
+ FEFaceEvaluation<dim, -1, 0, 1, number> fe_eval(data, true);
for (unsigned int face = face_range.first; face < face_range.second; face++)
{
fe_eval.reinit(face);
const unsigned int &,
const std::pair<unsigned int, unsigned int> &cell_range) const
{
- FEEvaluation<dim, fe_degree, n_q_points_1d, 1, number> phi(data);
+ FEEvaluation<dim, -1, 0, 1, number> phi(data);
+ AlignedVector<VectorizedArray<number>> local_diagonal_vector(
+ phi.dofs_per_cell);
for (unsigned int cell = cell_range.first; cell < cell_range.second; ++cell)
{
phi.reinit(cell);
- VectorizedArray<number> local_diagonal_vector[phi.static_dofs_per_cell];
for (unsigned int i = 0; i < phi.dofs_per_cell; ++i)
{
for (unsigned int j = 0; j < phi.dofs_per_cell; ++j)
phi.integrate(EvaluationFlags::gradients);
local_diagonal_vector[i] = phi.begin_dof_values()[i];
}
- for (unsigned int i = 0; i < phi.static_dofs_per_cell; ++i)
+ for (unsigned int i = 0; i < phi.dofs_per_cell; ++i)
phi.begin_dof_values()[i] = local_diagonal_vector[i];
phi.distribute_local_to_global(dst);
}
const unsigned int &,
const std::pair<unsigned int, unsigned int> &face_range) const
{
- FEFaceEvaluation<dim, fe_degree, n_q_points_1d, 1, number> phi(data, true);
- FEFaceEvaluation<dim, fe_degree, n_q_points_1d, 1, number> phi_outer(data,
- false);
+ FEFaceEvaluation<dim, -1, 0, 1, number> phi(data, true);
+ FEFaceEvaluation<dim, -1, 0, 1, number> phi_outer(data, false);
+ AlignedVector<VectorizedArray<number>> local_diagonal_vector(
+ phi.dofs_per_cell);
for (unsigned int face = face_range.first; face < face_range.second; face++)
{
phi.reinit(face);
phi_outer.reinit(face);
- VectorizedArray<number> local_diagonal_vector[phi.static_dofs_per_cell];
VectorizedArray<number> sigmaF =
(std::abs(
(phi.get_normal_vector(0) * phi.inverse_jacobian(0))[dim - 1]) +
const unsigned int &,
const std::pair<unsigned int, unsigned int> &face_range) const
{
- FEFaceEvaluation<dim, fe_degree, n_q_points_1d, 1, number> phi(data);
+ FEFaceEvaluation<dim, -1, 0, 1, number> phi(data);
+ AlignedVector<VectorizedArray<number>> local_diagonal_vector(
+ phi.dofs_per_cell);
for (unsigned int face = face_range.first; face < face_range.second; face++)
{
phi.reinit(face);
- VectorizedArray<number> local_diagonal_vector[phi.static_dofs_per_cell];
VectorizedArray<number> sigmaF =
std::abs(
(phi.get_normal_vector(0) * phi.inverse_jacobian(0))[dim - 1]) *
MatrixFree<dim, number> data;
LinearAlgebra::distributed::Vector<number> inverse_diagonal_entries;
+ int fe_degree;
};
-template <int dim, int fe_degree, int n_q_points_1d, typename number>
+template <int dim, typename number>
void
-do_test(const DoFHandler<dim> &dof, const bool also_test_parallel = false)
+do_test(const DoFHandler<dim> &dof, const unsigned n_q_points_1d)
{
deallog << "Testing " << dof.get_fe().get_name();
deallog << std::endl;
deallog << "Number of degrees of freedom: " << dof.n_dofs() << std::endl;
- MappingQ<dim> mapping(fe_degree + 1);
- LaplaceOperator<dim, fe_degree, n_q_points_1d, number> fine_matrix;
- fine_matrix.initialize(mapping, dof);
+ MappingQ<dim> mapping(n_q_points_1d);
+ LaplaceOperator<dim, number> fine_matrix;
+ fine_matrix.initialize(mapping, dof, n_q_points_1d);
LinearAlgebra::distributed::Vector<number> in, sol;
fine_matrix.initialize_dof_vector(in);
in = 1.;
// set up multigrid in analogy to step-37
- typedef LaplaceOperator<dim, fe_degree, n_q_points_1d, number>
- LevelMatrixType;
+ typedef LaplaceOperator<dim, number> LevelMatrixType;
MGLevelObject<LevelMatrixType> mg_matrices;
mg_matrices.resize(0, dof.get_triangulation().n_global_levels() - 1);
level < dof.get_triangulation().n_global_levels();
++level)
{
- mg_matrices[level].initialize(mapping, dof, level);
+ mg_matrices[level].initialize(mapping, dof, n_q_points_1d, level);
}
MGCoarseIterative<LevelMatrixType, number> mg_coarse;
-template <int dim, int fe_degree>
+template <int dim>
void
-test()
+test(const unsigned int fe_degree)
{
- for (int i = 5; i < 9 - fe_degree; ++i)
+ for (unsigned int i = 5; i < 9 - fe_degree; ++i)
{
parallel::distributed::Triangulation<dim> tria(
MPI_COMM_WORLD,
dof.distribute_dofs(fe);
dof.distribute_mg_dofs();
- do_test<dim, fe_degree, fe_degree + 1, double>(dof, true);
+ do_test<dim, double>(dof, fe_degree + 1);
}
}
{
deallog.push("2d");
- test<2, 1>();
- test<2, 2>();
+ test<2>(1);
+ test<2>(2);
deallog.pop();
deallog.push("3d");
- test<3, 1>();
- test<3, 2>();
+ test<3>(1);
+ test<3>(2);
deallog.pop();
}
}
-template <int dim,
- int fe_degree,
- int n_q_points_1d = fe_degree + 1,
- typename number = double>
+template <int dim, typename number = double>
class LaplaceOperator : public Subscriptor
{
public:
void
initialize(const Mapping<dim> & mapping,
const DoFHandler<dim> &dof_handler,
+ const unsigned int n_q_points_1d,
const unsigned int level = numbers::invalid_unsigned_int)
{
+ fe_degree = dof_handler.get_fe().degree;
+
const QGauss<1> quad(n_q_points_1d);
typename MatrixFree<dim, number>::AdditionalData addit_data;
addit_data.tasks_parallel_scheme =
const LinearAlgebra::distributed::Vector<number> &src,
const std::pair<unsigned int, unsigned int> &cell_range) const
{
- FEEvaluation<dim, fe_degree, n_q_points_1d, 1, number> phi(data);
+ FEEvaluation<dim, -1, 0, 1, number> phi(data);
for (unsigned int cell = cell_range.first; cell < cell_range.second; ++cell)
{
const LinearAlgebra::distributed::Vector<number> &src,
const std::pair<unsigned int, unsigned int> & face_range) const
{
- FEFaceEvaluation<dim, fe_degree, n_q_points_1d, 1, number> fe_eval(data,
- true);
- FEFaceEvaluation<dim, fe_degree, n_q_points_1d, 1, number> fe_eval_neighbor(
- data, false);
+ FEFaceEvaluation<dim, -1, 0, 1, number> fe_eval(data, true);
+ FEFaceEvaluation<dim, -1, 0, 1, number> fe_eval_neighbor(data, false);
for (unsigned int face = face_range.first; face < face_range.second; face++)
{
const LinearAlgebra::distributed::Vector<number> &src,
const std::pair<unsigned int, unsigned int> & face_range) const
{
- FEFaceEvaluation<dim, fe_degree, n_q_points_1d, 1, number> fe_eval(data,
- true);
+ FEFaceEvaluation<dim, -1, 0, 1, number> fe_eval(data, true);
for (unsigned int face = face_range.first; face < face_range.second; face++)
{
fe_eval.reinit(face);
const unsigned int &,
const std::pair<unsigned int, unsigned int> &cell_range) const
{
- FEEvaluation<dim, fe_degree, n_q_points_1d, 1, number> phi(data);
- FEFaceEvaluation<dim, fe_degree, n_q_points_1d, 1, number> phif(data);
+ FEEvaluation<dim, -1, 0, 1, number> phi(data);
+ FEFaceEvaluation<dim, -1, 0, 1, number> phif(data);
+ AlignedVector<VectorizedArray<number>> local_diagonal_vector(
+ phi.dofs_per_cell);
for (unsigned int cell = cell_range.first; cell < cell_range.second; ++cell)
{
phi.reinit(cell);
- VectorizedArray<number> local_diagonal_vector[phi.static_dofs_per_cell];
for (unsigned int i = 0; i < phi.dofs_per_cell; ++i)
{
for (unsigned int j = 0; j < phi.dofs_per_cell; ++j)
local_diagonal_vector[i] += phif.begin_dof_values()[i];
}
}
- for (unsigned int i = 0; i < phi.static_dofs_per_cell; ++i)
+ for (unsigned int i = 0; i < phi.dofs_per_cell; ++i)
phi.begin_dof_values()[i] = local_diagonal_vector[i];
phi.distribute_local_to_global(dst);
}
MatrixFree<dim, number> data;
LinearAlgebra::distributed::Vector<number> inverse_diagonal_entries;
+ int fe_degree;
};
-template <int dim, int fe_degree, int n_q_points_1d, typename number>
+template <int dim, typename number>
void
-do_test(const DoFHandler<dim> &dof, const bool also_test_parallel = false)
+do_test(const DoFHandler<dim> &dof, const unsigned int n_q_points_1d)
{
deallog << "Testing " << dof.get_fe().get_name();
deallog << std::endl;
deallog << "Number of degrees of freedom: " << dof.n_dofs() << std::endl;
- MappingQ<dim> mapping(fe_degree + 1);
- LaplaceOperator<dim, fe_degree, n_q_points_1d, number> fine_matrix;
- fine_matrix.initialize(mapping, dof);
+ MappingQ<dim> mapping(n_q_points_1d);
+ LaplaceOperator<dim, number> fine_matrix;
+ fine_matrix.initialize(mapping, dof, n_q_points_1d);
LinearAlgebra::distributed::Vector<number> in, sol;
fine_matrix.initialize_dof_vector(in);
in = 1.;
// set up multigrid in analogy to step-37
- typedef LaplaceOperator<dim, fe_degree, n_q_points_1d, number>
- LevelMatrixType;
+ typedef LaplaceOperator<dim, number> LevelMatrixType;
MGLevelObject<LevelMatrixType> mg_matrices;
mg_matrices.resize(0, dof.get_triangulation().n_global_levels() - 1);
level < dof.get_triangulation().n_global_levels();
++level)
{
- mg_matrices[level].initialize(mapping, dof, level);
+ mg_matrices[level].initialize(mapping, dof, n_q_points_1d, level);
}
MGCoarseIterative<LevelMatrixType, number> mg_coarse;
-template <int dim, int fe_degree>
+template <int dim>
void
-test()
+test(const unsigned int fe_degree)
{
- for (int i = 5; i < 9 - fe_degree; ++i)
+ for (unsigned int i = 5; i < 9 - fe_degree; ++i)
{
parallel::distributed::Triangulation<dim> tria(
MPI_COMM_WORLD,
dof.distribute_dofs(fe);
dof.distribute_mg_dofs();
- do_test<dim, fe_degree, fe_degree + 1, double>(dof, true);
+ do_test<dim, double>(dof, fe_degree + 1);
}
}
{
deallog.push("2d");
- test<2, 1>();
- test<2, 2>();
+ test<2>(1);
+ test<2>(2);
deallog.pop();
deallog.push("3d");
- test<3, 1>();
- test<3, 2>();
+ test<3>(1);
+ test<3>(2);
deallog.pop();
}
}
- template <int dim, int fe_degree>
+ template <int dim>
class SineGordonOperation
{
public:
- template <int dim, int fe_degree>
- SineGordonOperation<dim, fe_degree>::SineGordonOperation(
+ template <int dim>
+ SineGordonOperation<dim>::SineGordonOperation(
const MatrixFree<dim, double> &data_in,
const double time_step)
: data(data_in)
data.initialize_dof_vector(inv_mass_matrix);
- FEEvaluation<dim, fe_degree> fe_eval(data);
- const unsigned int n_q_points = fe_eval.n_q_points;
+ FEEvaluation<dim, -1> fe_eval(data);
+ const unsigned int n_q_points = fe_eval.n_q_points;
for (unsigned int cell = 0; cell < data.n_macro_cells(); ++cell)
{
- template <int dim, int fe_degree>
+ template <int dim>
void
- SineGordonOperation<dim, fe_degree>::local_apply(
+ SineGordonOperation<dim>::local_apply(
const MatrixFree<dim> & data,
LinearAlgebra::distributed::Vector<double> & dst,
const std::vector<LinearAlgebra::distributed::Vector<double> *> &src,
const std::pair<unsigned int, unsigned int> &cell_range) const
{
AssertDimension(src.size(), 2);
- FEEvaluation<dim, fe_degree> current(data), old(data);
+ FEEvaluation<dim, -1> current(data), old(data);
for (unsigned int cell = cell_range.first; cell < cell_range.second; ++cell)
{
current.reinit(cell);
- template <int dim, int fe_degree>
+ template <int dim>
void
- SineGordonOperation<dim, fe_degree>::apply(
+ SineGordonOperation<dim>::apply(
LinearAlgebra::distributed::Vector<double> & dst,
const std::vector<LinearAlgebra::distributed::Vector<double> *> &src) const
{
dst = 0;
- data.cell_loop(&SineGordonOperation<dim, fe_degree>::local_apply,
- this,
- dst,
- src);
+ data.cell_loop(&SineGordonOperation<dim>::local_apply, this, dst, src);
dst.scale(inv_mass_matrix);
}
previous_solutions.push_back(&old_solution);
previous_solutions.push_back(&old_old_solution);
- SineGordonOperation<dim, fe_degree> sine_gordon_op(matrix_free_data,
- time_step);
+ SineGordonOperation<dim> sine_gordon_op(matrix_free_data, time_step);
unsigned int timestep_number = 1;
- template <int dim, int fe_degree>
+ template <int dim>
class SineGordonOperation
{
public:
- template <int dim, int fe_degree>
- SineGordonOperation<dim, fe_degree>::SineGordonOperation(
+ template <int dim>
+ SineGordonOperation<dim>::SineGordonOperation(
const MatrixFree<dim, double> &data_in,
const double time_step)
: data(data_in)
data.initialize_dof_vector(inv_mass_matrix);
- FEEvaluation<dim, fe_degree> fe_eval(data);
- const unsigned int n_q_points = fe_eval.n_q_points;
+ FEEvaluation<dim, -1> fe_eval(data);
+ const unsigned int n_q_points = fe_eval.n_q_points;
for (unsigned int cell = 0; cell < data.n_macro_cells(); ++cell)
{
- template <int dim, int fe_degree>
+ template <int dim>
void
- SineGordonOperation<dim, fe_degree>::local_apply(
+ SineGordonOperation<dim>::local_apply(
const MatrixFree<dim> & data,
LinearAlgebra::distributed::Vector<double> & dst,
const std::vector<LinearAlgebra::distributed::Vector<double> *> &src,
const std::pair<unsigned int, unsigned int> &cell_range) const
{
AssertDimension(src.size(), 2);
- FEEvaluation<dim, fe_degree> current(data), old(data);
+ FEEvaluation<dim, -1> current(data), old(data);
deallog << "submit / sine values: ";
for (unsigned int cell = cell_range.first; cell < cell_range.second; ++cell)
{
- template <int dim, int fe_degree>
+ template <int dim>
void
- SineGordonOperation<dim, fe_degree>::apply(
+ SineGordonOperation<dim>::apply(
LinearAlgebra::distributed::Vector<double> & dst,
const std::vector<LinearAlgebra::distributed::Vector<double> *> &src) const
{
dst = 0;
- data.cell_loop(&SineGordonOperation<dim, fe_degree>::local_apply,
- this,
- dst,
- src);
+ data.cell_loop(&SineGordonOperation<dim>::local_apply, this, dst, src);
dst.scale(inv_mass_matrix);
}
previous_solutions.push_back(&old_solution);
previous_solutions.push_back(&old_old_solution);
- SineGordonOperation<dim, fe_degree> sine_gordon_op(matrix_free_data,
- time_step);
+ SineGordonOperation<dim> sine_gordon_op(matrix_free_data, time_step);
unsigned int timestep_number = 1;
- template <int dim, int fe_degree>
+ template <int dim>
class SineGordonOperation
{
public:
- template <int dim, int fe_degree>
- SineGordonOperation<dim, fe_degree>::SineGordonOperation(
+ template <int dim>
+ SineGordonOperation<dim>::SineGordonOperation(
const MatrixFree<dim, double> &data_in,
const double time_step)
: data(data_in)
data.initialize_dof_vector(inv_mass_matrix);
- FEEvaluation<dim, fe_degree> fe_eval(data);
- const unsigned int n_q_points = fe_eval.n_q_points;
+ FEEvaluation<dim, -1> fe_eval(data);
+ const unsigned int n_q_points = fe_eval.n_q_points;
for (unsigned int cell = 0; cell < data.n_macro_cells(); ++cell)
{
- template <int dim, int fe_degree>
+ template <int dim>
void
- SineGordonOperation<dim, fe_degree>::local_apply(
+ SineGordonOperation<dim>::local_apply(
const MatrixFree<dim> & data,
LinearAlgebra::distributed::Vector<double> & dst,
const std::vector<LinearAlgebra::distributed::Vector<double> *> &src,
const std::pair<unsigned int, unsigned int> &cell_range) const
{
AssertDimension(src.size(), 2);
- FEEvaluation<dim, fe_degree> current(data), old(data);
+ FEEvaluation<dim, -1> current(data), old(data);
for (unsigned int cell = cell_range.first; cell < cell_range.second; ++cell)
{
current.reinit(cell);
- template <int dim, int fe_degree>
+ template <int dim>
void
- SineGordonOperation<dim, fe_degree>::apply(
+ SineGordonOperation<dim>::apply(
LinearAlgebra::distributed::Vector<double> & dst,
const std::vector<LinearAlgebra::distributed::Vector<double> *> &src) const
{
dst = 0;
- data.cell_loop(&SineGordonOperation<dim, fe_degree>::local_apply,
- this,
- dst,
- src);
+ data.cell_loop(&SineGordonOperation<dim>::local_apply, this, dst, src);
dst.scale(inv_mass_matrix);
}
previous_solutions.push_back(&old_solution);
previous_solutions.push_back(&old_old_solution);
- SineGordonOperation<dim, fe_degree> sine_gordon_op(matrix_free_data,
- time_step);
+ SineGordonOperation<dim> sine_gordon_op(matrix_free_data, time_step);
unsigned int timestep_number = 1;