Removed default constructor and initialize() functions for FESeries objects.
+++ /dev/null
-New: Both classes FESeries::Fourier and FESeries::Legendre now offer a
-default constructor and can be initialized after their instantiation.
-<br>
-(Marc Fehling, 2020/01/21)
hp::QCollection<dim> quadrature_collection;
hp::QCollection<dim - 1> face_quadrature_collection;
- hp::QCollection<dim> fourier_q_collection;
- FESeries::Fourier<dim> fourier;
- std::vector<double> ln_k;
- Table<dim, std::complex<double>> fourier_coefficients;
+ hp::QCollection<dim> fourier_q_collection;
+ std::unique_ptr<FESeries::Fourier<dim>> fourier;
+ std::vector<double> ln_k;
+ Table<dim, std::complex<double>> fourier_coefficients;
AffineConstraints<double> constraints;
// Now we are ready to set-up the FESeries::Fourier object
const std::vector<unsigned int> n_coefficients_per_direction(
fe_collection.size(), N);
- fourier.initialize(n_coefficients_per_direction,
- fe_collection,
- fourier_q_collection);
+ fourier = std_cxx14::make_unique<FESeries::Fourier<dim>>(
+ n_coefficients_per_direction, fe_collection, fourier_q_collection);
// We need to resize the matrix of fourier coefficients according to the
// number of modes N.
local_dof_values.reinit(cell->get_fe().dofs_per_cell);
cell->get_dof_values(solution, local_dof_values);
- fourier.calculate(local_dof_values,
- cell->active_fe_index(),
- fourier_coefficients);
+ fourier->calculate(local_dof_values,
+ cell->active_fe_index(),
+ fourier_coefficients);
// The next thing, as explained in the introduction, is that we wanted
// to only fit our exponential decay of Fourier coefficients to the
public:
using CoefficientType = typename std::complex<double>;
- /**
- * Default constructor.
- *
- * Leaves all members in an empty or uninitialized state. Please call
- * initialize() once you have all data structures ready.
- */
- Fourier() = default;
-
/**
* Constructor that initializes all required data structures.
*
const hp::FECollection<dim, spacedim> &fe_collection,
const hp::QCollection<dim> & q_collection);
- /**
- * Initialize and overwrite all mandatory data structures for the
- * calculation calculation of transformation matrices.
- *
- * All previously calculated transformation matrices will be cleared.
- */
- void
- initialize(const std::vector<unsigned int> &n_coefficients_per_direction,
- const hp::FECollection<dim, spacedim> &fe_collection,
- const hp::QCollection<dim> & q_collection);
-
/**
* Calculate @p fourier_coefficients of the cell vector field given by
* @p local_dof_values corresponding to FiniteElement with
* Number of coefficients in each direction for each finite element in the
* registered hp::FECollection.
*/
- std::vector<unsigned int> n_coefficients_per_direction;
+ const std::vector<unsigned int> n_coefficients_per_direction;
/**
* hp::FECollection for which transformation matrices will be calculated.
/**
* hp::QCollection used in calculation of transformation matrices.
*/
- SmartPointer<const hp::QCollection<dim>> q_collection;
+ const hp::QCollection<dim> q_collection;
/**
* Angular frequencies $ 2 \pi {\bf k} $ .
public:
using CoefficientType = double;
- /**
- * Default constructor.
- *
- * Leaves all members in an empty or uninitialized state. Please call
- * initialize() once you have all data structures ready.
- */
- Legendre() = default;
-
/**
* Constructor that initializes all required data structures.
*
const hp::FECollection<dim, spacedim> &fe_collection,
const hp::QCollection<dim> & q_collection);
- /**
- * Initialize and overwrite all mandatory data structures for the
- * calculation of transformation matrices.
- *
- * All previously calculated transformation matrices will be cleared.
- */
- void
- initialize(const std::vector<unsigned int> &n_coefficients_per_direction,
- const hp::FECollection<dim, spacedim> &fe_collection,
- const hp::QCollection<dim> & q_collection);
-
/**
* Calculate @p legendre_coefficients of the cell vector field given by
* @p local_dof_values corresponding to FiniteElement with
* Number of coefficients in each direction for each finite element in the
* registered hp::FECollection.
*/
- std::vector<unsigned int> n_coefficients_per_direction;
+ const std::vector<unsigned int> n_coefficients_per_direction;
/**
* hp::FECollection for which transformation matrices will be calculated.
/**
* hp::QCollection used in calculation of transformation matrices.
*/
- SmartPointer<const hp::QCollection<dim>> q_collection;
+ const hp::QCollection<dim> q_collection;
/**
* Transformation matrices for each FiniteElement.
const bool only_flagged_cells = false);
/**
- * Number of modes for the default configuration of the Legendre series
- * expansion FESeries::Legendre.
+ * Returns a FESeries::Legendre object for Legendre series expansions with
+ * the default configuration for smoothness estimation purposes.
*
- * We use as many modes as the highest polynomial of all finite elements
- * used plus one, since we start with the first Legendre polynomial which is
- * just a constant.
- */
- template <int dim, int spacedim>
- std::vector<unsigned int>
- default_number_of_coefficients_per_direction(
- const hp::FECollection<dim, spacedim> &fe_collection);
-
- /**
- * Quadrature collection for the default configuration of the Legendre
- * series expansion FESeries::Legendre.
- *
- * We use Gaussian quadrature designed to yield exact results for the
+ * For each finite element of the provided @p fe_collection, we use as many
+ * modes as its polynomial degree plus one, since we start with the first
+ * Legendre polynomial which is just a constant. Further for each element,
+ * we use a Gaussian quadrature designed to yield exact results for the
* highest order Legendre polynomial used.
*/
template <int dim, int spacedim>
- hp::QCollection<dim>
- default_quadrature_collection(
- const hp::FECollection<dim, spacedim> &fe_collection);
+ FESeries::Legendre<dim, spacedim>
+ default_fe_series(const hp::FECollection<dim, spacedim> &fe_collection);
} // namespace Legendre
const bool only_flagged_cells = false);
/**
- * Number of modes for the default configuration of the Fourier series
- * expansion FESeries::Fourier.
- *
- * We use as many modes as the highest polynomial degree of all finite
- * elements used plus one, and at least three modes.
- */
- template <int dim, int spacedim>
- std::vector<unsigned int>
- default_number_of_coefficients_per_direction(
- const hp::FECollection<dim, spacedim> &fe_collection);
-
- /**
- * Quadrature collection for the default configuration of the Fourier series
- * expansion FESeries::Fourier.
+ * Returns a FESeries::Fourier object for Fourier series expansions with
+ * the default configuration for smoothness estimation purposes.
*
- * We use a 4-point Gaussian quarature iterated in each dimension by the
- * maximal wave number, which is the number of modes decresed by one since
- * we start with $k = 0$.
+ * For each finite element of the provided @p fe_collection, we use as many
+ * modes as its polynomial degree plus one, and at least three modes.
+ * Further for each element, we use a 4-point Gaussian quarature iterated in
+ * each dimension by the maximal wave number, which is the number of modes
+ * decreased by one since we start with $k = 0$.
*/
template <int dim, int spacedim>
- hp::QCollection<dim>
- default_quadrature_collection(
- const hp::FECollection<dim, spacedim> &fe_collection);
+ FESeries::Fourier<dim, spacedim>
+ default_fe_series(const hp::FECollection<dim, spacedim> &fe_collection);
} // namespace Fourier
} // namespace SmoothnessEstimator
const hp::QCollection<dim> & q_collection)
: n_coefficients_per_direction(n_coefficients_per_direction)
, fe_collection(&fe_collection)
- , q_collection(&q_collection)
+ , q_collection(q_collection)
, fourier_transform_matrices(fe_collection.size())
{
Assert(n_coefficients_per_direction.size() == fe_collection.size() &&
return (
(n_coefficients_per_direction == fourier.n_coefficients_per_direction) &&
(*fe_collection == *(fourier.fe_collection)) &&
- (*q_collection == *(fourier.q_collection)) &&
+ (q_collection == fourier.q_collection) &&
(k_vectors == fourier.k_vectors) &&
(fourier_transform_matrices == fourier.fourier_transform_matrices));
}
task_group += Threads::new_task([&, fe]() {
ensure_existence(n_coefficients_per_direction,
*fe_collection,
- *q_collection,
+ q_collection,
k_vectors,
fe,
fourier_transform_matrices);
- template <int dim, int spacedim>
- void
- Fourier<dim, spacedim>::initialize(
- const std::vector<unsigned int> & n_coefficients_per_direction,
- const hp::FECollection<dim, spacedim> &fe_collection,
- const hp::QCollection<dim> & q_collection)
- {
- Assert(n_coefficients_per_direction.size() == fe_collection.size() &&
- n_coefficients_per_direction.size() == q_collection.size(),
- ExcMessage("All parameters are supposed to have the same size."));
-
- // set members
- this->n_coefficients_per_direction = n_coefficients_per_direction;
- this->fe_collection =
- SmartPointer<const hp::FECollection<dim, spacedim>>(&fe_collection);
- this->q_collection =
- SmartPointer<const hp::QCollection<dim>>(&q_collection);
-
- // clean up auxiliary members
- k_vectors.reset_values();
- const unsigned int max_n_coefficients_per_direction =
- *std::max_element(n_coefficients_per_direction.cbegin(),
- n_coefficients_per_direction.cend());
- set_k_vectors(k_vectors, max_n_coefficients_per_direction);
-
- fourier_transform_matrices.clear();
- fourier_transform_matrices.resize(fe_collection.size());
-
- unrolled_coefficients.clear();
- // reserve sufficient memory
- unrolled_coefficients.reserve(k_vectors.n_elements());
- }
-
-
-
template <int dim, int spacedim>
unsigned int
Fourier<dim, spacedim>::get_n_coefficients_per_direction(
const unsigned int cell_active_fe_index,
Table<dim, CoefficientType> &fourier_coefficients)
{
- Assert(fe_collection != nullptr && q_collection != nullptr,
- ExcMessage("Initialize this FESeries object first!"));
for (unsigned int d = 0; d < dim; ++d)
AssertDimension(fourier_coefficients.size(d),
n_coefficients_per_direction[cell_active_fe_index]);
ensure_existence(n_coefficients_per_direction,
*fe_collection,
- *q_collection,
+ q_collection,
k_vectors,
cell_active_fe_index,
fourier_transform_matrices);
const hp::QCollection<dim> & q_collection)
: n_coefficients_per_direction(n_coefficients_per_direction)
, fe_collection(&fe_collection)
- , q_collection(&q_collection)
+ , q_collection(q_collection)
, legendre_transform_matrices(fe_collection.size())
{
Assert(n_coefficients_per_direction.size() == fe_collection.size() &&
return (
(n_coefficients_per_direction == legendre.n_coefficients_per_direction) &&
(*fe_collection == *(legendre.fe_collection)) &&
- (*q_collection == *(legendre.q_collection)) &&
+ (q_collection == legendre.q_collection) &&
(legendre_transform_matrices == legendre.legendre_transform_matrices));
}
task_group += Threads::new_task([&, fe]() {
ensure_existence(n_coefficients_per_direction,
*fe_collection,
- *q_collection,
+ q_collection,
fe,
legendre_transform_matrices);
});
- template <int dim, int spacedim>
- void
- Legendre<dim, spacedim>::initialize(
- const std::vector<unsigned int> & n_coefficients_per_direction,
- const hp::FECollection<dim, spacedim> &fe_collection,
- const hp::QCollection<dim> & q_collection)
- {
- Assert(n_coefficients_per_direction.size() == fe_collection.size() &&
- n_coefficients_per_direction.size() == q_collection.size(),
- ExcMessage("All parameters are supposed to have the same size."));
-
- // set members
- this->n_coefficients_per_direction = n_coefficients_per_direction;
- this->fe_collection =
- SmartPointer<const hp::FECollection<dim, spacedim>>(&fe_collection);
- this->q_collection =
- SmartPointer<const hp::QCollection<dim>>(&q_collection);
-
- // clean up auxiliary members
- legendre_transform_matrices.clear();
- legendre_transform_matrices.resize(fe_collection.size());
-
- unrolled_coefficients.clear();
- // reserve sufficient memory
- const unsigned int max_n_coefficients_per_direction =
- *std::max_element(n_coefficients_per_direction.cbegin(),
- n_coefficients_per_direction.cend());
- unrolled_coefficients.reserve(
- Utilities::fixed_power<dim>(max_n_coefficients_per_direction));
- }
-
-
-
template <int dim, int spacedim>
unsigned int
Legendre<dim, spacedim>::get_n_coefficients_per_direction(
const unsigned int cell_active_fe_index,
Table<dim, CoefficientType> & legendre_coefficients)
{
- Assert(fe_collection != nullptr && q_collection != nullptr,
- ExcMessage("Initialize this FESeries object first!"));
for (unsigned int d = 0; d < dim; ++d)
AssertDimension(legendre_coefficients.size(d),
n_coefficients_per_direction[cell_active_fe_index]);
ensure_existence(n_coefficients_per_direction,
*fe_collection,
- *q_collection,
+ q_collection,
cell_active_fe_index,
legendre_transform_matrices);
template <int dim, int spacedim>
- std::vector<unsigned int>
- default_number_of_coefficients_per_direction(
- const hp::FECollection<dim, spacedim> &fe_collection)
+ FESeries::Legendre<dim, spacedim>
+ default_fe_series(const hp::FECollection<dim, spacedim> &fe_collection)
{
+ // Default number of coefficients per direction.
std::vector<unsigned int> n_coefficients_per_direction;
for (unsigned int i = 0; i < fe_collection.size(); ++i)
n_coefficients_per_direction.push_back(fe_collection[i].degree + 1);
- return n_coefficients_per_direction;
- }
-
-
-
- template <int dim, int spacedim>
- hp::QCollection<dim>
- default_quadrature_collection(
- const hp::FECollection<dim, spacedim> &fe_collection)
- {
- const std::vector<unsigned int> n_modes =
- default_number_of_coefficients_per_direction(fe_collection);
-
+ // Default quadrature collection.
+ //
// We initialize a FESeries::Legendre expansion object object which will
// be used to calculate the expansion coefficients. In addition to the
// hp::FECollection, we need to provide quadrature rules hp::QCollection
// rule. As a default, we use the same quadrature formula for each finite
// element, namely a Gauss formula that yields exact results for the
// highest order Legendre polynomial used.
-
+ //
// We start with the zeroth Legendre polynomial which is just a constant,
// so the highest Legendre polynomial will be of order (n_modes - 1).
hp::QCollection<dim> q_collection;
for (unsigned int i = 0; i < fe_collection.size(); ++i)
{
- const QGauss<dim> quadrature(n_modes[i]);
+ const QGauss<dim> quadrature(n_coefficients_per_direction[i]);
const QSorted<dim> quadrature_sorted(quadrature);
q_collection.push_back(quadrature_sorted);
}
- return q_collection;
+ return FESeries::Legendre<dim, spacedim>(n_coefficients_per_direction,
+ fe_collection,
+ q_collection);
}
} // namespace Legendre
template <int dim, int spacedim>
- std::vector<unsigned int>
- default_number_of_coefficients_per_direction(
- const hp::FECollection<dim, spacedim> &fe_collection)
+ FESeries::Fourier<dim, spacedim>
+ default_fe_series(const hp::FECollection<dim, spacedim> &fe_collection)
{
+ // Default number of coefficients per direction.
std::vector<unsigned int> n_coefficients_per_direction;
for (unsigned int i = 0; i < fe_collection.size(); ++i)
n_coefficients_per_direction.push_back(
std::max<unsigned int>(3, fe_collection[i].degree + 1));
- return n_coefficients_per_direction;
- }
-
-
-
- template <int dim, int spacedim>
- hp::QCollection<dim>
- default_quadrature_collection(
- const hp::FECollection<dim, spacedim> &fe_collection)
- {
- const std::vector<unsigned int> n_modes =
- default_number_of_coefficients_per_direction(fe_collection);
-
+ // Default quadrature collection.
+ //
// We initialize a series expansion object object which will be used to
// calculate the expansion coefficients. In addition to the
// hp::FECollection, we need to provide quadrature rules hp::QCollection
hp::QCollection<dim> q_collection;
for (unsigned int i = 0; i < fe_collection.size(); ++i)
{
- const QIterated<dim> quadrature(base_quadrature, n_modes[i] - 1);
+ const QIterated<dim> quadrature(base_quadrature,
+ n_coefficients_per_direction[i] - 1);
const QSorted<dim> quadrature_sorted(quadrature);
q_collection.push_back(quadrature_sorted);
}
- return q_collection;
+ return FESeries::Fourier<dim, spacedim>(n_coefficients_per_direction,
+ fe_collection,
+ q_collection);
}
} // namespace Fourier
} // namespace SmoothnessEstimator
for (deal_II_dimension : DIMENSIONS; deal_II_space_dimension : SPACE_DIMENSIONS)
{
#if deal_II_dimension <= deal_II_space_dimension
- template std::vector<unsigned int> SmoothnessEstimator::Legendre::
- default_number_of_coefficients_per_direction<deal_II_dimension,
- deal_II_space_dimension>(
- const hp::FECollection<deal_II_dimension, deal_II_space_dimension> &);
- template hp::QCollection<deal_II_dimension> SmoothnessEstimator::Legendre::
- default_quadrature_collection<deal_II_dimension, deal_II_space_dimension>(
- const hp::FECollection<deal_II_dimension, deal_II_space_dimension> &);
+ template FESeries::Legendre<deal_II_dimension, deal_II_space_dimension>
+ SmoothnessEstimator::Legendre::default_fe_series<deal_II_dimension,
+ deal_II_space_dimension>(
+ const hp::FECollection<deal_II_dimension, deal_II_space_dimension> &);
- template std::vector<unsigned int> SmoothnessEstimator::Fourier::
- default_number_of_coefficients_per_direction<deal_II_dimension,
- deal_II_space_dimension>(
- const hp::FECollection<deal_II_dimension, deal_II_space_dimension> &);
- template hp::QCollection<deal_II_dimension> SmoothnessEstimator::Fourier::
- default_quadrature_collection<deal_II_dimension, deal_II_space_dimension>(
- const hp::FECollection<deal_II_dimension, deal_II_space_dimension> &);
+ template FESeries::Fourier<deal_II_dimension, deal_II_space_dimension>
+ SmoothnessEstimator::Fourier::default_fe_series<deal_II_dimension,
+ deal_II_space_dimension>(
+ const hp::FECollection<deal_II_dimension, deal_II_space_dimension> &);
#endif
}
hp::QCollection<dim - 1> quadrature_face;
- std::vector<unsigned int> n_coefficients_per_direction;
- hp::QCollection<dim> expansion_q_collection;
- FESeries::Legendre<dim> legendre;
+ std::unique_ptr<FESeries::Legendre<dim>> legendre;
};
template <int dim>
// after the FECollection has been generated, create a corresponding legendre
// series expansion object
- n_coefficients_per_direction =
- SmoothnessEstimator::Legendre::default_number_of_coefficients_per_direction(
- Laplace<dim>::fe);
- expansion_q_collection =
- SmoothnessEstimator::Legendre::default_quadrature_collection(
- Laplace<dim>::fe);
- legendre.initialize(n_coefficients_per_direction,
- Laplace<dim>::fe,
- expansion_q_collection);
+ legendre = std_cxx14::make_unique<FESeries::Legendre<dim>>(
+ SmoothnessEstimator::Legendre::default_fe_series(Laplace<dim>::fe));
}
Vector<float> smoothness_indicators(
Laplace<dim>::triangulation.n_active_cells());
SmoothnessEstimator::Legendre::coefficient_decay_per_direction(
- legendre,
+ *legendre,
Laplace<dim>::dof_handler,
Laplace<dim>::solution,
smoothness_indicators);
Vector<double> solution;
Vector<double> system_rhs;
- const unsigned int max_degree;
- hp::QCollection<dim> fourier_q_collection;
- FESeries::Fourier<dim> fourier;
+ const unsigned int max_degree;
+ hp::QCollection<dim> fourier_q_collection;
+ std::unique_ptr<FESeries::Fourier<dim>> fourier;
};
const std::vector<unsigned int> n_coefficients_per_direction(
fe_collection.size(), max_degree);
- fourier.initialize(n_coefficients_per_direction,
- fe_collection,
- fourier_q_collection);
+ fourier = std_cxx14::make_unique<FESeries::Fourier<dim>>(
+ n_coefficients_per_direction, fe_collection, fourier_q_collection);
}
Vector<float> smoothness_indicators;
SmoothnessEstimator::Fourier::coefficient_decay(
- fourier,
+ *fourier,
dof_handler,
solution,
smoothness_indicators,
hp::QCollection<dim> quadrature_collection;
hp::QCollection<dim - 1> face_quadrature_collection;
- hp::QCollection<dim> fourier_q_collection;
- FESeries::Fourier<dim> fourier;
+ hp::QCollection<dim> fourier_q_collection;
+ std::unique_ptr<FESeries::Fourier<dim>> fourier;
AffineConstraints<double> constraints;
const std::vector<unsigned int> n_coefficients_per_direction(
fe_collection.size(), max_degree);
- fourier.initialize(n_coefficients_per_direction,
- fe_collection,
- fourier_q_collection);
+ fourier = std_cxx14::make_unique<FESeries::Fourier<dim>>(
+ n_coefficients_per_direction, fe_collection, fourier_q_collection);
}
Vector<float> smoothness_indicators(triangulation.n_active_cells());
SmoothnessEstimator::Fourier::coefficient_decay(
- fourier,
+ *fourier,
dof_handler,
solution,
smoothness_indicators,
hp::QCollection<dim> quadrature_collection;
hp::QCollection<dim - 1> face_quadrature_collection;
- hp::QCollection<dim> fourier_q_collection;
- FESeries::Fourier<dim> fourier;
+ hp::QCollection<dim> fourier_q_collection;
+ std::unique_ptr<FESeries::Fourier<dim>> fourier;
AffineConstraints<double> constraints;
const std::vector<unsigned int> n_coefficients_per_direction(
fe_collection.size(), max_degree);
- fourier.initialize(n_coefficients_per_direction,
- fe_collection,
- fourier_q_collection);
+ fourier = std_cxx14::make_unique<FESeries::Fourier<dim>>(
+ n_coefficients_per_direction, fe_collection, fourier_q_collection);
}
Vector<float> smoothness_indicators(triangulation.n_active_cells());
SmoothnessEstimator::Fourier::coefficient_decay(
- fourier,
+ *fourier,
dof_handler,
solution,
smoothness_indicators,
for (unsigned int p = 1; p <= max_poly; p++)
fe_collection.push_back(FE_Q<dim>(p));
- const unsigned int fe_index = poly_degree - 1;
- const std::vector<unsigned int> n_coefficients_per_direction =
- SmoothnessEstimator::Legendre::default_number_of_coefficients_per_direction(
- fe_collection);
- const unsigned int n_modes = n_coefficients_per_direction[fe_index];
+ FESeries::Legendre<dim> legendre =
+ SmoothnessEstimator::Legendre::default_fe_series(fe_collection);
+
+ const unsigned int fe_index = poly_degree - 1;
+ const unsigned int n_modes =
+ legendre.get_n_coefficients_per_direction(fe_index);
// custom predicate:
// p-ref for linear elements and use j=1,...,pe otherwise.
Vector<double> values(dof_handler.n_dofs());
VectorTools::interpolate(dof_handler, func, values);
- hp::QCollection<dim> q_collection =
- SmoothnessEstimator::Legendre::default_quadrature_collection(fe_collection);
- FESeries::Legendre<dim> legendre(n_coefficients_per_direction,
- fe_collection,
- q_collection);
-
const Table<dim, double> &coeff_in = func.get_coefficients();
Table<dim, double> coeff_out;
resize(coeff_out, n_modes);
for (unsigned int p = 1; p <= max_poly; ++p)
fe_collection.push_back(FE_Q<dim>(p));
- const unsigned int fe_index = poly_degree - 1;
- const std::vector<unsigned int> n_coefficients_per_direction =
- SmoothnessEstimator::Fourier::default_number_of_coefficients_per_direction(
- fe_collection);
- const unsigned int n_modes = n_coefficients_per_direction[fe_index];
+ FESeries::Fourier<dim> fourier =
+ SmoothnessEstimator::Fourier::default_fe_series(fe_collection);
+
+ const unsigned int fe_index = poly_degree - 1;
+ const unsigned int n_modes =
+ fourier.get_n_coefficients_per_direction(fe_index);
Assert((poly_degree >= 1) && (poly_degree <= max_poly), ExcInternalError());
Assert((n_modes >= 3) && (n_modes <= max_poly + 1), ExcInternalError());
local_dof_values.reinit(cell->get_fe().dofs_per_cell);
cell->get_dof_values(values, local_dof_values);
- hp::QCollection<dim> q_collection =
- SmoothnessEstimator::Fourier::default_quadrature_collection(fe_collection);
- FESeries::Fourier<dim> fourier(n_coefficients_per_direction,
- fe_collection,
- q_collection);
-
Table<dim, std::complex<double>> coeff_out;
coeff_out.reinit(size);
fourier.calculate(local_dof_values, cell->active_fe_index(), coeff_out);
projects / dealii.git / commitdiff